diff --git a/.github/workflows/build_python.yml b/.github/workflows/build_python.yml index 5b4e74f..aff6ef5 100644 --- a/.github/workflows/build_python.yml +++ b/.github/workflows/build_python.yml @@ -59,11 +59,15 @@ jobs: python -m unittest cd .. done - - name: Build Pyodide wheel + - name: Build and test Pyodide wheel if: matrix.os == 'ubuntu-latest' run: | eval "$($MAMBA_EXE shell activate cibuildwheel)" - CIBW_BUILD="cp312*" python -m cibuildwheel --output-dir wheelhouse --platform pyodide + CIBW_BUILD="cp312*" python -m cibuildwheel --output-dir dist --platform pyodide + mamba install nodejs + npm install + npm test + mv dist/*wasm*.whl wheelhouse/ - name: Upload release wheels if: | contains(github.event.pull_request.title, 'RELEASE') && diff --git a/.gitignore b/.gitignore index c899876..3e687a3 100644 --- a/.gitignore +++ b/.gitignore @@ -10,7 +10,10 @@ build dist libMcPhase.egg-info libmcphase.egg-info -emsdk +emsdk* Emscripten.cmake +node_modules +package-lock.json libmcphase/*pyd +libmcphase/libmcphase.cpython* diff --git a/CMakeLists.txt b/CMakeLists.txt index 26b2226..bb55f4a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,11 +1,10 @@ -cmake_minimum_required (VERSION 3.13) +cmake_minimum_required (VERSION 3.15) project(libMcPhase) set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) set(CMAKE_MACOSX_RPATH TRUE) set(CMAKE_CXX_STANDARD 11) set(CXX_STANDARD_REQUIRED 11) -cmake_policy(SET CMP0148 OLD) # New policy gives error when cannot find shared libs set(LIBMCPHASE_PYTHON_MODULE libmcphase) @@ -45,3 +44,6 @@ add_subdirectory(src) pybind11_add_module(${LIBMCPHASE_PYTHON_MODULE} MODULE) target_include_directories(${LIBMCPHASE_PYTHON_MODULE} PUBLIC src/include) add_subdirectory(src/libmcphase) + +# Destination name must match name of project in pyproject.toml +install(TARGETS ${LIBMCPHASE_PYTHON_MODULE} DESTINATION libmcphase) diff --git a/libmcphase/__init__.py b/libmcphase/__init__.py index 8323039..bf23788 100644 --- a/libmcphase/__init__.py +++ b/libmcphase/__init__.py @@ -1,4 +1,4 @@ from .libmcphase import * from . import _version -__version__ = _version.get_versions()['version'] +__version__ = _version.__version__ diff --git a/libmcphase/_version.py b/libmcphase/_version.py deleted file mode 100644 index 9e65edb..0000000 --- a/libmcphase/_version.py +++ /dev/null @@ -1,683 +0,0 @@ - -# This file helps to compute a version number in source trees obtained from -# git-archive tarball (such as those provided by githubs download-from-tag -# feature). Distribution tarballs (built by setup.py sdist) and build -# directories (produced by setup.py build) will contain a much shorter file -# that just contains the computed version number. - -# This file is released into the public domain. -# Generated by versioneer-0.29 -# https://github.com/python-versioneer/python-versioneer - -"""Git implementation of _version.py.""" - -import errno -import os -import re -import subprocess -import sys -from typing import Any, Callable, Dict, List, Optional, Tuple -import functools - - -def get_keywords() -> Dict[str, str]: - """Get the keywords needed to look up the version information.""" - # these strings will be replaced by git during git-archive. - # setup.py/versioneer.py will grep for the variable names, so they must - # each be defined on a line of their own. _version.py will just call - # get_keywords(). - git_refnames = "$Format:%d$" - git_full = "$Format:%H$" - git_date = "$Format:%ci$" - keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} - return keywords - - -class VersioneerConfig: - """Container for Versioneer configuration parameters.""" - - VCS: str - style: str - tag_prefix: str - parentdir_prefix: str - versionfile_source: str - verbose: bool - - -def get_config() -> VersioneerConfig: - """Create, populate and return the VersioneerConfig() object.""" - # these strings are filled in when 'setup.py versioneer' creates - # _version.py - cfg = VersioneerConfig() - cfg.VCS = "git" - cfg.style = "pep440" - cfg.tag_prefix = "v" - cfg.parentdir_prefix = "None" - cfg.versionfile_source = "libmcphase/_version.py" - cfg.verbose = False - return cfg - - -class NotThisMethod(Exception): - """Exception raised if a method is not valid for the current scenario.""" - - -LONG_VERSION_PY: Dict[str, str] = {} -HANDLERS: Dict[str, Dict[str, Callable]] = {} - - -def register_vcs_handler(vcs: str, method: str) -> Callable: # decorator - """Create decorator to mark a method as the handler of a VCS.""" - def decorate(f: Callable) -> Callable: - """Store f in HANDLERS[vcs][method].""" - if vcs not in HANDLERS: - HANDLERS[vcs] = {} - HANDLERS[vcs][method] = f - return f - return decorate - - -def run_command( - commands: List[str], - args: List[str], - cwd: Optional[str] = None, - verbose: bool = False, - hide_stderr: bool = False, - env: Optional[Dict[str, str]] = None, -) -> Tuple[Optional[str], Optional[int]]: - """Call the given command(s).""" - assert isinstance(commands, list) - process = None - - popen_kwargs: Dict[str, Any] = {} - if sys.platform == "win32": - # This hides the console window if pythonw.exe is used - startupinfo = subprocess.STARTUPINFO() - startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW - popen_kwargs["startupinfo"] = startupinfo - - for command in commands: - try: - dispcmd = str([command] + args) - # remember shell=False, so use git.cmd on windows, not just git - process = subprocess.Popen([command] + args, cwd=cwd, env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None), **popen_kwargs) - break - except OSError as e: - if e.errno == errno.ENOENT: - continue - if verbose: - print("unable to run %s" % dispcmd) - print(e) - return None, None - else: - if verbose: - print("unable to find command, tried %s" % (commands,)) - return None, None - stdout = process.communicate()[0].strip().decode() - if process.returncode != 0: - if verbose: - print("unable to run %s (error)" % dispcmd) - print("stdout was %s" % stdout) - return None, process.returncode - return stdout, process.returncode - - -def versions_from_parentdir( - parentdir_prefix: str, - root: str, - verbose: bool, -) -> Dict[str, Any]: - """Try to determine the version from the parent directory name. - - Source tarballs conventionally unpack into a directory that includes both - the project name and a version string. We will also support searching up - two directory levels for an appropriately named parent directory - """ - rootdirs = [] - - for _ in range(3): - dirname = os.path.basename(root) - if dirname.startswith(parentdir_prefix): - return {"version": dirname[len(parentdir_prefix):], - "full-revisionid": None, - "dirty": False, "error": None, "date": None} - rootdirs.append(root) - root = os.path.dirname(root) # up a level - - if verbose: - print("Tried directories %s but none started with prefix %s" % - (str(rootdirs), parentdir_prefix)) - raise NotThisMethod("rootdir doesn't start with parentdir_prefix") - - -@register_vcs_handler("git", "get_keywords") -def git_get_keywords(versionfile_abs: str) -> Dict[str, str]: - """Extract version information from the given file.""" - # the code embedded in _version.py can just fetch the value of these - # keywords. When used from setup.py, we don't want to import _version.py, - # so we do it with a regexp instead. This function is not used from - # _version.py. - keywords: Dict[str, str] = {} - try: - with open(versionfile_abs, "r") as fobj: - for line in fobj: - if line.strip().startswith("git_refnames ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["refnames"] = mo.group(1) - if line.strip().startswith("git_full ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["full"] = mo.group(1) - if line.strip().startswith("git_date ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["date"] = mo.group(1) - except OSError: - pass - return keywords - - -@register_vcs_handler("git", "keywords") -def git_versions_from_keywords( - keywords: Dict[str, str], - tag_prefix: str, - verbose: bool, -) -> Dict[str, Any]: - """Get version information from git keywords.""" - if "refnames" not in keywords: - raise NotThisMethod("Short version file found") - date = keywords.get("date") - if date is not None: - # Use only the last line. Previous lines may contain GPG signature - # information. - date = date.splitlines()[-1] - - # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant - # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 - # -like" string, which we must then edit to make compliant), because - # it's been around since git-1.5.3, and it's too difficult to - # discover which version we're using, or to work around using an - # older one. - date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - refnames = keywords["refnames"].strip() - if refnames.startswith("$Format"): - if verbose: - print("keywords are unexpanded, not using") - raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = {r.strip() for r in refnames.strip("()").split(",")} - # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of - # just "foo-1.0". If we see a "tag: " prefix, prefer those. - TAG = "tag: " - tags = {r[len(TAG):] for r in refs if r.startswith(TAG)} - if not tags: - # Either we're using git < 1.8.3, or there really are no tags. We use - # a heuristic: assume all version tags have a digit. The old git %d - # expansion behaves like git log --decorate=short and strips out the - # refs/heads/ and refs/tags/ prefixes that would let us distinguish - # between branches and tags. By ignoring refnames without digits, we - # filter out many common branch names like "release" and - # "stabilization", as well as "HEAD" and "master". - tags = {r for r in refs if re.search(r'\d', r)} - if verbose: - print("discarding '%s', no digits" % ",".join(refs - tags)) - if verbose: - print("likely tags: %s" % ",".join(sorted(tags))) - for ref in sorted(tags): - # sorting will prefer e.g. "2.0" over "2.0rc1" - if ref.startswith(tag_prefix): - r = ref[len(tag_prefix):] - # Filter out refs that exactly match prefix or that don't start - # with a number once the prefix is stripped (mostly a concern - # when prefix is '') - if not re.match(r'\d', r): - continue - if verbose: - print("picking %s" % r) - return {"version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": None, - "date": date} - # no suitable tags, so version is "0+unknown", but full hex is still there - if verbose: - print("no suitable tags, using unknown + full revision id") - return {"version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": "no suitable tags", "date": None} - - -@register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs( - tag_prefix: str, - root: str, - verbose: bool, - runner: Callable = run_command -) -> Dict[str, Any]: - """Get version from 'git describe' in the root of the source tree. - - This only gets called if the git-archive 'subst' keywords were *not* - expanded, and _version.py hasn't already been rewritten with a short - version string, meaning we're inside a checked out source tree. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - - # GIT_DIR can interfere with correct operation of Versioneer. - # It may be intended to be passed to the Versioneer-versioned project, - # but that should not change where we get our version from. - env = os.environ.copy() - env.pop("GIT_DIR", None) - runner = functools.partial(runner, env=env) - - _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=not verbose) - if rc != 0: - if verbose: - print("Directory %s not under git control" % root) - raise NotThisMethod("'git rev-parse --git-dir' returned error") - - # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] - # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = runner(GITS, [ - "describe", "--tags", "--dirty", "--always", "--long", - "--match", f"{tag_prefix}[[:digit:]]*" - ], cwd=root) - # --long was added in git-1.5.5 - if describe_out is None: - raise NotThisMethod("'git describe' failed") - describe_out = describe_out.strip() - full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) - if full_out is None: - raise NotThisMethod("'git rev-parse' failed") - full_out = full_out.strip() - - pieces: Dict[str, Any] = {} - pieces["long"] = full_out - pieces["short"] = full_out[:7] # maybe improved later - pieces["error"] = None - - branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], - cwd=root) - # --abbrev-ref was added in git-1.6.3 - if rc != 0 or branch_name is None: - raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") - branch_name = branch_name.strip() - - if branch_name == "HEAD": - # If we aren't exactly on a branch, pick a branch which represents - # the current commit. If all else fails, we are on a branchless - # commit. - branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) - # --contains was added in git-1.5.4 - if rc != 0 or branches is None: - raise NotThisMethod("'git branch --contains' returned error") - branches = branches.split("\n") - - # Remove the first line if we're running detached - if "(" in branches[0]: - branches.pop(0) - - # Strip off the leading "* " from the list of branches. - branches = [branch[2:] for branch in branches] - if "master" in branches: - branch_name = "master" - elif not branches: - branch_name = None - else: - # Pick the first branch that is returned. Good or bad. - branch_name = branches[0] - - pieces["branch"] = branch_name - - # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] - # TAG might have hyphens. - git_describe = describe_out - - # look for -dirty suffix - dirty = git_describe.endswith("-dirty") - pieces["dirty"] = dirty - if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] - - # now we have TAG-NUM-gHEX or HEX - - if "-" in git_describe: - # TAG-NUM-gHEX - mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) - if not mo: - # unparsable. Maybe git-describe is misbehaving? - pieces["error"] = ("unable to parse git-describe output: '%s'" - % describe_out) - return pieces - - # tag - full_tag = mo.group(1) - if not full_tag.startswith(tag_prefix): - if verbose: - fmt = "tag '%s' doesn't start with prefix '%s'" - print(fmt % (full_tag, tag_prefix)) - pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" - % (full_tag, tag_prefix)) - return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] - - # distance: number of commits since tag - pieces["distance"] = int(mo.group(2)) - - # commit: short hex revision ID - pieces["short"] = mo.group(3) - - else: - # HEX: no tags - pieces["closest-tag"] = None - out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root) - pieces["distance"] = len(out.split()) # total number of commits - - # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip() - # Use only the last line. Previous lines may contain GPG signature - # information. - date = date.splitlines()[-1] - pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - - return pieces - - -def plus_or_dot(pieces: Dict[str, Any]) -> str: - """Return a + if we don't already have one, else return a .""" - if "+" in pieces.get("closest-tag", ""): - return "." - return "+" - - -def render_pep440(pieces: Dict[str, Any]) -> str: - """Build up version string, with post-release "local version identifier". - - Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you - get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty - - Exceptions: - 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += plus_or_dot(pieces) - rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0+untagged.%d.g%s" % (pieces["distance"], - pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_branch(pieces: Dict[str, Any]) -> str: - """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . - - The ".dev0" means not master branch. Note that .dev0 sorts backwards - (a feature branch will appear "older" than the master branch). - - Exceptions: - 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0" - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += "+untagged.%d.g%s" % (pieces["distance"], - pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def pep440_split_post(ver: str) -> Tuple[str, Optional[int]]: - """Split pep440 version string at the post-release segment. - - Returns the release segments before the post-release and the - post-release version number (or -1 if no post-release segment is present). - """ - vc = str.split(ver, ".post") - return vc[0], int(vc[1] or 0) if len(vc) == 2 else None - - -def render_pep440_pre(pieces: Dict[str, Any]) -> str: - """TAG[.postN.devDISTANCE] -- No -dirty. - - Exceptions: - 1: no tags. 0.post0.devDISTANCE - """ - if pieces["closest-tag"]: - if pieces["distance"]: - # update the post release segment - tag_version, post_version = pep440_split_post(pieces["closest-tag"]) - rendered = tag_version - if post_version is not None: - rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"]) - else: - rendered += ".post0.dev%d" % (pieces["distance"]) - else: - # no commits, use the tag as the version - rendered = pieces["closest-tag"] - else: - # exception #1 - rendered = "0.post0.dev%d" % pieces["distance"] - return rendered - - -def render_pep440_post(pieces: Dict[str, Any]) -> str: - """TAG[.postDISTANCE[.dev0]+gHEX] . - - The ".dev0" means dirty. Note that .dev0 sorts backwards - (a dirty tree will appear "older" than the corresponding clean one), - but you shouldn't be releasing software with -dirty anyways. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%s" % pieces["short"] - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += "+g%s" % pieces["short"] - return rendered - - -def render_pep440_post_branch(pieces: Dict[str, Any]) -> str: - """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . - - The ".dev0" means not master branch. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%s" % pieces["short"] - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += "+g%s" % pieces["short"] - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_old(pieces: Dict[str, Any]) -> str: - """TAG[.postDISTANCE[.dev0]] . - - The ".dev0" means dirty. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - return rendered - - -def render_git_describe(pieces: Dict[str, Any]) -> str: - """TAG[-DISTANCE-gHEX][-dirty]. - - Like 'git describe --tags --dirty --always'. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render_git_describe_long(pieces: Dict[str, Any]) -> str: - """TAG-DISTANCE-gHEX[-dirty]. - - Like 'git describe --tags --dirty --always -long'. - The distance/hash is unconditional. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render(pieces: Dict[str, Any], style: str) -> Dict[str, Any]: - """Render the given version pieces into the requested style.""" - if pieces["error"]: - return {"version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None} - - if not style or style == "default": - style = "pep440" # the default - - if style == "pep440": - rendered = render_pep440(pieces) - elif style == "pep440-branch": - rendered = render_pep440_branch(pieces) - elif style == "pep440-pre": - rendered = render_pep440_pre(pieces) - elif style == "pep440-post": - rendered = render_pep440_post(pieces) - elif style == "pep440-post-branch": - rendered = render_pep440_post_branch(pieces) - elif style == "pep440-old": - rendered = render_pep440_old(pieces) - elif style == "git-describe": - rendered = render_git_describe(pieces) - elif style == "git-describe-long": - rendered = render_git_describe_long(pieces) - else: - raise ValueError("unknown style '%s'" % style) - - return {"version": rendered, "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], "error": None, - "date": pieces.get("date")} - - -def get_versions() -> Dict[str, Any]: - """Get version information or return default if unable to do so.""" - # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have - # __file__, we can work backwards from there to the root. Some - # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which - # case we can only use expanded keywords. - - cfg = get_config() - verbose = cfg.verbose - - try: - return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, - verbose) - except NotThisMethod: - pass - - try: - root = os.path.realpath(__file__) - # versionfile_source is the relative path from the top of the source - # tree (where the .git directory might live) to this file. Invert - # this to find the root from __file__. - for _ in cfg.versionfile_source.split('/'): - root = os.path.dirname(root) - except NameError: - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to find root of source tree", - "date": None} - - try: - pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) - return render(pieces, cfg.style) - except NotThisMethod: - pass - - try: - if cfg.parentdir_prefix: - return versions_from_parentdir(cfg.parentdir_prefix, root, verbose) - except NotThisMethod: - pass - - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to compute version", "date": None} diff --git a/package.json b/package.json new file mode 100644 index 0000000..1b67608 --- /dev/null +++ b/package.json @@ -0,0 +1,14 @@ +{ + "scripts": { + "test": "jest" + }, + "jest": { + "testEnvironment": "node", + "globalSetup": "/tests/jestSetup.js" + }, + "dependencies": { + "glob": "^11.1.0", + "jest": "^29.7.0", + "pyodide": "^0.27.7" + } +} diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..348480c --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,46 @@ +[build-system] +requires = ["scikit-build-core>=0.10", "pybind11"] +build-backend = "scikit_build_core.build" + +[project] +name = "libmcphase" +dynamic = ["version"] +description = "A mean-field Monte Carlo simulation program for magnetic phase diagrams and excitations" +readme = "README.md" +authors = [ + { name = "Duc Le", email = "duc.le@stfc.ac.uk" }, + { name = "Martin Rotter" }, +] +requires-python = ">=3.8" +license = "GPL-3.0-or-later" +classifiers = [ + "Development Status :: 2 - Pre-Alpha", + "Intended Audience :: Science/Research", + "Operating System :: Microsoft :: Windows :: Windows 10", + "Operating System :: POSIX :: Linux", + "Programming Language :: C++", + "Programming Language :: Python :: 3", + "Topic :: Scientific/Engineering :: Physics", +] +dependencies = ["numpy>=1.18"] + +[project.urls] +Repository = "https://github.com/mducle/libmcphase" + +[tool.scikit-build.cmake.define] +CMAKE_CXX_FLAGS_RELEASE = "-O2 -DNDEBUG" + +[tool.scikit-build] +metadata.version.provider = "scikit_build_core.metadata.setuptools_scm" +sdist.include = ["libmcphase/_version.py"] +cmake.args = ["-G Unix Makefiles"] +build.tool-args = ["-j8"] +#build.verbose = true +#logging.level = "INFO" +[[tool.scikit-build.overrides]] +if.platform-system = "^win" +cmake.args = [] +build.tool-args = [] + +[tool.setuptools_scm] # Section required +write_to = "libmcphase/_version.py" diff --git a/setup.py b/setup.py deleted file mode 100644 index 9e7f38f..0000000 --- a/setup.py +++ /dev/null @@ -1,142 +0,0 @@ -import os -import re -import sys -import subprocess -import importlib.util -from sysconfig import get_platform -from subprocess import CalledProcessError, check_output, check_call -from distutils.version import LooseVersion -from setuptools import setup, Extension, find_packages -from setuptools.command.build_ext import build_ext -import versioneer - -# We can use cmake provided from pip which (normally) gets installed at /bin -# Except that in the manylinux builds it's placed at /opt/python/[version]/bin/ -# (as a symlink at least) which is *not* on the path. -# If cmake is a known module, import it and use it tell us its binary directory -if (cmakemod := importlib.util.find_spec('cmake')) and cmakemod.loader: - import cmake - CMAKE_BIN = cmake.CMAKE_BIN_DIR + os.path.sep + 'cmake' -else: - CMAKE_BIN = 'cmake' - -def get_cmake(): - return CMAKE_BIN - - -def is_vsc(): - platform = get_platform() - return platform.startswith("win") - - -def is_mingw(): - platform = get_platform() - return platform.startswith("mingw") - - -class CMakeExtension(Extension): - def __init__(self, name, sourcedir=''): - Extension.__init__(self, name, sources=[]) - self.sourcedir = os.path.abspath(sourcedir) - - -class CMakeBuild(build_ext): - def run(self): - try: - out = check_output([get_cmake(), '--version']) - except OSError: - raise RuntimeError("CMake must be installed to build" + - " the following extensions: " + - ", ".join(e.name for e in self.extensions)) - - rex = r'version\s*([\d.]+)' - cmake_version = LooseVersion(re.search(rex, out.decode()).group(1)) - if cmake_version < '3.13.0': - raise RuntimeError("CMake >= 3.13.0 is required") - - for ext in self.extensions: - self.build_extension(ext) - - def build_extension(self, ext): - extdir = os.path.dirname(self.get_ext_fullpath(ext.name)) - extdir = os.path.abspath(extdir) - cmake_args = [] - if is_vsc(): - if sys.maxsize > 2**32: - cmake_args += ['-A', 'x64'] - else: - cmake_args += ['-A', 'Win32'] - - if is_mingw(): - cmake_args += ['-G','Unix Makefiles'] # Must be two entries to work - - cmake_args += ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + extdir, - '-DPYTHON_EXECUTABLE=' + sys.executable] - - cfg = 'RelWithDebInfo' if self.debug else 'Release' - build_args = ['--config', cfg] - - # make sure all library files end up in one place - cmake_args += ["-DCMAKE_BUILD_WITH_INSTALL_RPATH=TRUE"] - cmake_args += ["-DCMAKE_INSTALL_RPATH={}".format("$ORIGIN")] - - if is_vsc(): - cmake_lib_out_dir = '-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}' - cmake_args += [cmake_lib_out_dir.format(cfg.upper(), extdir)] - cmake_args += ['-DCMAKE_BUILD_TYPE=' + cfg] - build_args += ['--', '/m:4'] - else: - cmake_args += ['-DCMAKE_BUILD_TYPE=' + cfg] - build_args += ['--', '-j'] - - env = os.environ.copy() - cxxflags = '{} -DVERSION_INFO=\\"{}\\"'.format( - env.get('CXXFLAGS', ''), self.distribution.get_version()) - env['CXXFLAGS'] = cxxflags - if not os.path.exists(self.build_temp): - os.makedirs(self.build_temp) - check_call( - [get_cmake(), ext.sourcedir] + cmake_args, - cwd=self.build_temp, env=env) - check_call( - [get_cmake(), '--build', '.', '--target', "libmcphase"] + build_args, - cwd=self.build_temp) - - -with open("README.md", "r") as fh: - LONG_DESCRIPTION = fh.read() - -cmdclass = versioneer.get_cmdclass() -cmdclass['build_ext'] = CMakeBuild - -KEYWORDARGS = dict( - name='libmcphase', - version=versioneer.get_version(), - author='Duc Le, Martin Rotter', - author_email='duc.le@stfc.ac.uk', - description='A mean-field Monte Carlo simulation program for magnetic phase diagrams and excitations.', - long_description=LONG_DESCRIPTION, - long_description_content_type="text/markdown", - ext_modules=[CMakeExtension('libmcphase.libmcphase')], - packages=find_packages(), - install_requires = ['numpy'], - extras_require = {'interactive':['matplotlib>=2.2.0',],}, - cmdclass=cmdclass, - url="https://github.com/mducle/libmcphase", - zip_safe=False, - license="GPL-3.0-or-later", - classifiers=[ - "Development Status :: 2 - Pre-Alpha", - "Intended Audience :: Science/Research", - "Operating System :: Microsoft :: Windows :: Windows 10", - "Operating System :: POSIX :: Linux", - "Programming Language :: C++", - "Programming Language :: Python :: 3", - "Topic :: Scientific/Engineering :: Physics", - ] -) - -try: - setup(**KEYWORDARGS) -except CalledProcessError: - print("Failed to build the extension!") diff --git a/src/include/cf1ion.hpp b/src/include/cf1ion.hpp index e834ce9..078e93d 100644 --- a/src/include/cf1ion.hpp +++ b/src/include/cf1ion.hpp @@ -2,7 +2,7 @@ * * A class for calculating the crystal field Hamiltonian in Russell-Saunders (LS-) coupling. * - * (C) 2018 Duc Le - duc.le@stfc.ac.uk + * (C) 2018-2026 Duc Le - duc.le@stfc.ac.uk * This program is licensed under the GNU General Purpose License, version 3. Please see the LICENSE file */ @@ -12,6 +12,10 @@ #include "eigen.hpp" #include "cfpars.hpp" #include "physprop.hpp" +#include +#include +#include +#include namespace libMcPhase { @@ -29,6 +33,10 @@ class cf1ion: public cfpars, public physprop { RowMatrixXcd _hamiltonian(bool upper=true); void calc_mag_ops(); void fill_upper(); + std::vector _set_pars(bool use_sym=false, bool use_rand=false); + void _fill_ham_m(RowMatrixXcd &ham, int k, int q, double val, double rme); + void _fill_ham_p(RowMatrixXcd &ham, int k, int q, double val, double rme); + void _fill_ham_0(RowMatrixXcd &ham, int k, double val, double rme); public: // Setters @@ -48,6 +56,8 @@ class cf1ion: public cfpars, public physprop { std::tuple eigensystem(); RowMatrixXcd zeeman_hamiltonian(double H, std::vector Hdir); std::vector calculate_moments_matrix(RowMatrixXcd ev); + std::vector split2range(double E0, bool use_sym=false, bool reset_pars=false); + void fitengy(std::vector E0, bool use_sym=false); }; // class cf1ion diff --git a/src/include/cfpars.hpp b/src/include/cfpars.hpp index 744579e..ea9407d 100644 --- a/src/include/cfpars.hpp +++ b/src/include/cfpars.hpp @@ -27,16 +27,76 @@ namespace libMcPhase { // Conversion factors for different energy units[from][to], order: [meV, cm, K]. static const std::array ENERGYCONV = { {1., 8.065544005, 11.6045221} }; +// Conversion factors from Stevens to Wybourn normalisation +static const std::array lambda = { + {sqrt(6.)/2., sqrt(6.), 1./2., sqrt(6.), sqrt(6.)/2., // l=2 + sqrt(70.)/8., sqrt(35.)/2., sqrt(10.)/4., sqrt(5.)/2., 1./8., sqrt(5.)/2., sqrt(10.)/4., sqrt(35.)/2., sqrt(70.)/8., // l=4 + sqrt(231.)/16., 3*sqrt(77.)/8., 3*sqrt(14.)/16., sqrt(105.)/8., sqrt(105.)/16., sqrt(42.)/8., // l=6, m=-6 to m=-1 + 1./16., sqrt(42.)/8., sqrt(105.)/16., sqrt(105.)/8., 3*sqrt(14.)/16., 3*sqrt(77.)/8., sqrt(231.)/16.} }; + +// Normalisation factors for Fabi parameters, defined as sqrt( sum_{Jz, Jz'} ||^2 / (2J+1) ) +static const std::array< std::array, 17> FABINORM = {{ +/* J=0 */ {0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.}, +/* J=1/2 */ {0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.}, +/* J=1 */ {-0.8164965809, -0.4082482905, 1.4142135624, 0.4082482905, 0.8164965809, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.}, +/* J=3/2 */ {-1.7320508076, -0.8660254038, 3., 0.8660254038, 1.7320508076, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.}, +/* J=2 */ {-2.8982753492, -1.4491376746, 5.0199601592, 1.4491376746, 2.8982753492, -7.5894663844, -2.683281573, -10.0399203184, -7.0992957397, 44.8998886413, + 7.0992957397, 10.0399203184, 2.683281573, 7.5894663844, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.}, +/* J=5/2 */ {-4.3204937989, -2.1602468995, 7.4833147735, 2.1602468995, 4.3204937989, -21.9089023002, -7.7459666924, -28.9827534924, -20.4939015319, 129.6148139682, + 20.4939015319, 28.9827534924, 7.7459666924, 21.9089023002, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.}, +/* J=3 */ {-6., -3., 10.3923048454, 3., 6., -47.5694980303, -16.8183573174, -62.9285308902, -44.4971909226, 281.4249455894, 44.4971909226, 62.9285308902, + 16.8183573174, 47.5694980303, -192.4280941769, -55.5492059864, -260.5488712041, -142.708494091, -285.416988182, -225.6419413901, 2068.0425527537, + 225.6419413901, 285.416988182, 142.708494091, 260.5488712041, 55.5492059864, 192.4280941769}, +/* J=7/2 */ {-7.9372539332, -3.9686269666, 13.7477270849, 3.9686269666, 7.9372539332, -88.9943818451, -31.4642654451, -117.7285012221, -83.2466215531, + 526.4978632435, 83.2466215531, 117.7285012221, 31.4642654451, 88.9943818451, -673.4983296193, -194.4222209522, -911.9210492142, -499.4797293184, + -998.9594586368, -789.7467948653, 7238.1489346379, 789.7467948653, 998.9594586368, 499.4797293184, 911.9210492142, 194.4222209522, 673.4983296193}, +/* J=4 */ {-10.1324561024, -5.0662280512, 17.5499287748, 5.0662280512, 10.1324561024, -151.2613632095, -53.4789678285, -200.0999750125, -141.4920492466, + 894.8742928479, 141.4920492466, 200.0999750125, 53.4789678285, 151.2613632095, -1738.9652095427, -501.9960159204, -2354.5700244418, -1289.6511156123, + -2579.3022312246, -2039.117456156, 18688.8201874811, 2039.117456156, 2579.3022312246, 1289.6511156123, 2354.5700244418, 501.9960159204, 1738.9652095427}, +/* J=9/2 */ {-12.585706178, -6.292853089, 21.7990825495, 6.292853089, 12.585706178, -240.119970015, -84.895229548, -317.64886274, -224.6116648796, 1420.5689001242, + 224.6116648796, 317.64886274, 84.895229548, 240.119970015, -3809.881887933, -1099.8181667894, -5158.6044624491, -2825.4840293302, -5650.9680586604, + -4467.4825125567, 40945.1535593652, 4467.4825125567, 5650.9680586604, 2825.4840293302, 5158.6044624491, 1099.8181667894, 3809.881887933,}, +/* J=5 */ {-15.2970585408, -7.6485292704, 26.495282599, 7.6485292704, 15.2970585408, -361.994475096, -127.9843740462, -478.8736785416, -338.6148254285, + 2141.588195709, 338.6148254285, 478.8736785416, 127.9843740462, 361.994475096, -7488.7552066718, -2161.8174172336, -10139.8224836533, -5553.8095033949, + -11107.6190067899, -8781.3438607083, 80482.3458902634, 8781.3438607083, 11107.6190067899, 5553.8095033949, 10139.8224836533, 2161.8174172336, 7488.7552066718}, +/* J=11/2 */{-18.2665450118, -9.1332725059, 31.6385840391, 9.1332725059, 18.2665450118, -523.984732602, -185.2565788306, -693.1666466298, -490.1428363243, 3099.9354831996, + 490.1428363243, 693.1666466298, 185.2565788306, 523.984732602, -13603.9994119377, -3927.1363612689, -18419.9022798711, -10088.9959857262, -20177.9919714525, + -15952.1033095953, 146203.4418199517, 15952.1033095953, 20177.9919714525, 10088.9959857262, 18419.9022798711, 3927.1363612689, 13603.9994119377}, +/* J=6 */ {-21.4941852602, -10.7470926301, 37.229020938, 10.7470926301, 21.4941852602, -733.8664728682, -259.4609797253, -970.8140913687, -686.4692272783, + 4341.6126036301, 686.4692272783, 970.8140913687, 259.4609797253, 733.8664728682, -23258.7690659144, -6714.2282906125, -31492.5221893413, -17249.1647958342, + -34498.3295916684, -27273.3242452147, 249964.1456135413, 27273.3242452147, 34498.3295916684, 17249.1647958342, 31492.5221893413, 6714.2282906125, 23258.7690659144}, +/* J=13/2 */{-24.9799919936, -12.4899959968, 43.2666153056, 12.4899959968, 24.9799919936, -1000.0914243922, -353.5857139971, -1322.9965986351, -935.4998663816, 5916.6206570981, + 935.4998663816, 1322.9965986351, 353.5857139971, 1000.0914243922, -37884.3955814452, -10936.2829935168, -51295.7141066804, -28095.8197195648, -56191.6394391296, + -44423.391521649, 407147.1085492319, 44423.391521649, 56191.6394391296, 28095.8197195648, 51295.7141066804, 10936.2829935168, 37884.3955814452}, +/* J=7 */ {-28.723973727, -14.3619868635, 49.7513818904, 14.3619868635, 28.723973727, -1331.7873704162, -470.8579403599, -1761.7890906689, -1245.7730130325, + 7878.9603375065, 1245.7730130325, 1761.7890906689, 470.8579403599, 1331.7873704162, -59298.458664623, -17117.990536275, -80290.4925878525, -43976.9139435682, + -87953.8278871363, -69533.6062634465, 637286.0280909977, 69533.6062634465, 87953.8278871363, 43976.9139435682, 80290.4925878525, 17117.990536275, 59298.458664623}, +/* J=15/2 */{-32.7261363439, -16.363068172, 56.6833308831, 16.363068172, 32.7261363439, -1738.7581775509, -614.7438490949, -2300.1608639397, -1626.4593447117, 10286.6321019078, + 1626.4593447117, 2300.1608639397, 614.7438490949, 1738.7581775509, -89767.4996866906, -25913.6450542952, -121545.7691571368, -66573.3595366795, -133146.7190733591, + -105261.7238125996, 964739.6343055468, 105261.7238125996, 133146.7190733591, 66573.3595366795, 121545.7691571368, 25913.6450542952, 89767.4996866906}, +/* J=8 */ {-36.9864840178, -18.4932420089, 64.0624695122, 18.4932420089, 36.9864840178, -2231.4838112789, -788.9486675317, -2951.9756096553, -2087.3619714846, + 13201.6362622214, 2087.3619714846, 2951.9756096553, 788.9486675317, 2231.4838112789, -132074.3790445369, -38126.589147208, -178829.5546043774, -97948.9810054194, + -195897.9620108387, -154870.9372348473, 1419415.585654885, 154870.9372348473, 195897.9620108387, 97948.9810054194, 178829.5546043774, 38126.589147208, 132074.3790445369}, +}}; + +// Point symmetry tables - classes are triclinic, monoclinic, etc. to cubic +static const std::array SYM_CLASS = {{ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 }}; +static const std::array BLM_SYM = {{ 3, 1, 511, 1, 7, 11, 33, 3, 1, 1023, 1, 7, 97, 543, 163, 1, 11, 33, 3, 1, 1023, 1, 7, 97, 543, 1, 999 }}; + + class cfpars { public: enum class Units {meV = 0, cm = 1, K = 2}; enum class Normalisation {Stevens, Wybourne}; - enum class Type {Alm, Blm, Llm, ARlm}; + enum class Type {Alm, Blm, Llm, ARlm, Nlm}; enum class Blm {B22S = 0, B21S = 1, B20 = 2, B21 = 3, B22 = 4, B44S = 5, B43S = 6, B42S = 7, B41S = 8, B40 = 9, B41 = 10, B42 = 11, B43 = 12, B44 = 13, B66S = 14, B65S = 15, B64S = 16, B63S = 17, B62S = 18, B61S = 19, B60 = 20, B61 = 21, B62 = 22, B63 = 23, B64 = 24, B65 = 25, B66 = 26}; + enum class Sym {Ci=0, C1=1, C2=10, Cs=11, C2h=12, C2v=20, D2=21, D2h=22, C4=30, S4=31, C4h=32, + D4=40, C4v=41, D2d=42, D4h=43, C3=50, S6=51, D3=60, C3v=61, D3d=62, C6=71, C3h=72, C6h=73, + D6=80, C6v=81, D3h=82, D6h=83, T=90, Th=91, Td=92, O=93, Oh=94}; protected: std::array m_Bi{}; // Internal array of values (in Wybourne/theta_k in meV) @@ -54,10 +114,13 @@ class cfpars { bool m_convertible = false; // True if can convert between types and normalisations racah m_racah{}; // Class to calc n-j symbols and cache factorials int m_n = 1; // Number of open shell electrons in this configuration + Sym m_sym = Sym::C1; // Point symmetry of site public: // Methods virtual void getfromionname(const std::string &ionname); + bool is_sym_allowed(const Blm blm); + std::vector get_sym_allowed_Blm(); // Getters Units get_unit() const { return m_unit; } Normalisation get_normalisation() const { return m_norm; } @@ -70,6 +133,7 @@ class cfpars { double beta() const { return m_stevfact[1]; } double gamma() const { return m_stevfact[2]; } double get_J() const { return (double)(m_J2 / 2.); } + Sym get_sym() const { return m_sym; } // Setters virtual void set_unit(const Units newunit); virtual void set_type(const Type newtype); @@ -78,6 +142,7 @@ class cfpars { virtual void set_GJ(const double GJ) { m_GJ = GJ; } virtual void set(const Blm blm, double val); virtual void set(int l, int m, double val); + void set_sym(const Sym newsym) { m_sym = newsym; } // Constructors cfpars(); cfpars(const int J2); diff --git a/src/include/physprop.hpp b/src/include/physprop.hpp index 37e1246..8462747 100644 --- a/src/include/physprop.hpp +++ b/src/include/physprop.hpp @@ -11,6 +11,8 @@ #include "eigen.hpp" #include #include +#include +#include namespace libMcPhase { @@ -45,6 +47,9 @@ static const double NAMEV = 96.48533212; // J/mol = N_A * meV // EPSILON to determine if energy levels are degenerate or not static const double DELTA_EPS = 1e-6; +// The neutron-magnetic cross-section in milibarn/sr/uB^2 +static const double MAGXSEC_MBSR = 48.28133274; + // Base class for physical properties calculations. Must derive and implement zeeman_hamiltonian class physprop { protected: @@ -58,8 +63,9 @@ class physprop { virtual std::vector calculate_moments_matrix(RowMatrixXcd ev) = 0; VectorXd calculate_boltzmann(VectorXd en, double T); VectorXd heatcapacity(std::vector Tvec); - RowMatrixXd magnetisation(std::vector H, std::vector Hdir, std::vector Tvec, MagUnits type); + RowMatrixXd magnetisation(std::vector Tvec, std::vector H, std::vector Hdir, MagUnits type); VectorXd susceptibility(std::vector T, std::vector Hdir, MagUnits type); + RowMatrixXd peaks(double T); }; // Mapping for Python binding to map string to enum diff --git a/src/libmcphase/pycf1ion.cpp b/src/libmcphase/pycf1ion.cpp index 1113d7d..35ba7de 100644 --- a/src/libmcphase/pycf1ion.cpp +++ b/src/libmcphase/pycf1ion.cpp @@ -36,10 +36,14 @@ void wrap_cf1ion(py::module &m) { .def("zeeman_hamiltonian", &cf1ion::zeeman_hamiltonian, "the Zeeman Hamiltonian") .def("calculate_boltzmann", &cf1ion::calculate_boltzmann, "") .def("heatcapacity", &cf1ion::heatcapacity, "the heat capacity of the crystal field Hamiltonian in J/mol/K") - .def("magnetisation", [](cf1ion &self, std::vector H, std::vector Hdir, std::vector T, std::string unit) { return self.magnetisation(H, Hdir, T, + .def("magnetisation", [](cf1ion &self, std::vector T, std::vector H, std::vector Hdir, std::string unit) { return self.magnetisation(T, H, Hdir, set_enum(unit, mag_unit_names, "Invalid magnetic unit, must be one of: 'bohr', 'cgs', or 'SI'")); }) .def("susceptibility", [](cf1ion &self, std::vector T, std::vector Hdir, std::string unit) { return self.susceptibility(T, Hdir, - set_enum(unit, mag_unit_names, "Invalid magnetic unit, must be one of: 'bohr', 'cgs', or 'SI'")); }); + set_enum(unit, mag_unit_names, "Invalid magnetic unit, must be one of: 'bohr', 'cgs', or 'SI'")); }) + .def("peaks", &cf1ion::peaks, "list of peaks with intensity in mb/sr") + .def("split2range", [](cf1ion &self, double E, bool s) { return self.split2range(E, s); }, py::arg("Energy_splitting"), py::arg("use_sym")=false, + "returns maximum absolute values of Blm which when sampled will give on average E0 splitting") + .def("fitengy", &cf1ion::fitengy, py::arg("E"), py::arg("use_sym"), "update parameters to fit input energies using Newman-Ng algorithm"); } diff --git a/src/libmcphase/pycfpars.cpp b/src/libmcphase/pycfpars.cpp index 1589757..c5365ab 100644 --- a/src/libmcphase/pycfpars.cpp +++ b/src/libmcphase/pycfpars.cpp @@ -19,14 +19,27 @@ static const std::unordered_map Blm_names = { {"B62S", cfpars::Blm::B62S}, {"B61S", cfpars::Blm::B61S}, {"B60", cfpars::Blm::B60}, {"B61", cfpars::Blm::B61}, {"B62", cfpars::Blm::B62}, {"B63", cfpars::Blm::B63}, {"B64", cfpars::Blm::B64}, {"B65", cfpars::Blm::B65}, {"B66", cfpars::Blm::B66} }; +static const std::array Blmvec = {{"B22S", "B21S", "B20", "B21", "B22", "B44S", "B43S", "B42S", "B41S", + "B40", "B41", "B42", "B43", "B44", "B66S", "B65S", "B64S", "B63S", "B62S", "B61S", "B60", "B61", "B62", "B63", "B64", "B65", "B66" }}; + static const std::unordered_map type_names = { - {"Alm", cfpars::Type::Alm}, {"Blm", cfpars::Type::Blm}, {"Llm", cfpars::Type::Llm}, {"ARlm", cfpars::Type::ARlm} }; -static const std::string type_err = "Invalid type name, must be one of 'Alm', 'ARlm', 'Blm', 'Llm', 'Vlm' or 'Wlm'"; + {"Alm", cfpars::Type::Alm}, {"Blm", cfpars::Type::Blm}, {"Llm", cfpars::Type::Llm}, {"ARlm", cfpars::Type::ARlm}, {"Nlm", cfpars::Type::Nlm} }; +static const std::string type_err = "Invalid type name, must be one of 'Alm', 'ARlm', 'Blm', 'Llm', 'Nlm', 'Vlm' or 'Wlm'"; static const std::unordered_map unit_names = { {"meV", cfpars::Units::meV}, {"cm", cfpars::Units::cm}, {"K", cfpars::Units::K} }; static const std::string unit_err = "Invalid unit, must be one of 'meV', 'cm', or 'K'"; +static const std::unordered_map sym_names = { + {"Ci", cfpars::Sym::Ci}, {"C1", cfpars::Sym::C1}, {"C2", cfpars::Sym::C2}, {"Cs", cfpars::Sym::Cs}, {"C2h", cfpars::Sym::C2h}, + {"C2v", cfpars::Sym::C2v}, {"D2", cfpars::Sym::D2}, {"D2h", cfpars::Sym::D2h}, {"C4", cfpars::Sym::C4}, {"S4", cfpars::Sym::S4}, + {"C4h", cfpars::Sym::C4h}, {"D4", cfpars::Sym::D4}, {"C4v", cfpars::Sym::C4v}, {"D2d", cfpars::Sym::D2d}, {"D4h", cfpars::Sym::D4h}, + {"C3", cfpars::Sym::C3}, {"S6", cfpars::Sym::S6}, {"D3", cfpars::Sym::D3}, {"C3v", cfpars::Sym::C3v}, {"D3d", cfpars::Sym::D3d}, + {"C6", cfpars::Sym::C6}, {"C3h", cfpars::Sym::C3h}, {"C6h", cfpars::Sym::C6h}, {"D6", cfpars::Sym::D6}, {"C6v", cfpars::Sym::C6v}, + {"D3h", cfpars::Sym::D3h}, {"D6h", cfpars::Sym::D6h}, {"T", cfpars::Sym::T}, {"Th", cfpars::Sym::Th}, {"Td", cfpars::Sym::Td}, + {"O", cfpars::Sym::O}, {"Oh", cfpars::Sym::Oh} }; +static const std::string sym_err = "Invalid point symmetry, must be a Schoenflies symbol"; + void cf_parse(cfpars *cls, py::args args, py::kwargs kwargs, bool is_ic1ion) { if (!args && !kwargs) { return; @@ -60,6 +73,9 @@ void cf_parse(cfpars *cls, py::args args, py::kwargs kwargs, bool is_ic1ion) { if (kwargs.contains("unit")) { cls->set_unit(set_enum(kwargs["unit"].cast(), unit_names, unit_err)); } + if (kwargs.contains("sym")) { + cls->set_sym(set_enum(kwargs["sym"].cast(), sym_names, sym_err)); + } if (kwargs) { for (auto const &bname : Blm_names) { if (kwargs.contains(bname.first.c_str())) { @@ -92,16 +108,33 @@ void wrap_cfpars(py::module &m) { .value("Alm", cfpars::Type::Alm) .value("Blm", cfpars::Type::Blm) .value("Llm", cfpars::Type::Llm) - .value("ARlm", cfpars::Type::ARlm); + .value("ARlm", cfpars::Type::ARlm) + .value("Nlm", cfpars::Type::Nlm); + + py::enum_(pycfpars, "Sym") + .value("Ci", cfpars::Sym::Ci).value("C1", cfpars::Sym::C1) + .value("C2", cfpars::Sym::C2).value("Cs", cfpars::Sym::Cs).value("C2h", cfpars::Sym::C2h) + .value("C2v", cfpars::Sym::C2v).value("D2", cfpars::Sym::D2).value("D2h", cfpars::Sym::D2h) + .value("C4", cfpars::Sym::C4).value("S4", cfpars::Sym::S4).value("C4h", cfpars::Sym::C4h) + .value("D4", cfpars::Sym::D4).value("C4v", cfpars::Sym::C4v).value("D2d", cfpars::Sym::D2d) .value("D4h", cfpars::Sym::D4h) + .value("C3", cfpars::Sym::C3).value("S6", cfpars::Sym::S6) + .value("D3", cfpars::Sym::D3).value("C3v", cfpars::Sym::C3v).value("D3d", cfpars::Sym::D3d) + .value("C6", cfpars::Sym::C6).value("C3h", cfpars::Sym::C3h).value("C6h", cfpars::Sym::C6h) + .value("D6", cfpars::Sym::D6).value("C6v", cfpars::Sym::C6v).value("D3h", cfpars::Sym::D3h) .value("D6h", cfpars::Sym::D6h) + .value("T", cfpars::Sym::T).value("Th", cfpars::Sym::Th).value("Td", cfpars::Sym::Td).value("O", cfpars::Sym::O).value("Oh", cfpars::Sym::Oh); pycfpars.def(py::init<>()) .def(py::init(), py::arg("ionname")) .def(py::init(), py::arg("J")) .def(py::init(&cfpars_init), cfpars_init_str) + .def("get_sym_allowed_pars", [](cfpars &self) { std::vector r0 = self.get_sym_allowed_Blm(); std::vector rv(r0.size()); + std::transform(r0.begin(), r0.end(), rv.begin(), [](cfpars::Blm b) { return Blmvec[(int)b]; }); return rv; }) .def_property("unit", &cfpars::get_unit, [](cfpars &self, std::string unit) { self.set_unit(set_enum(unit, unit_names, unit_err)); }, "energy unit of the parameters") .def_property("type", &cfpars::get_type, [](cfpars &self, std::string type) { self.set_type(set_enum(type, type_names, type_err)); }, "type of CF parameters. When changed, parameters values will be automatically converted.") + .def_property("sym", &cfpars::get_sym, [](cfpars &self, std::string sym) { self.set_sym(set_enum(sym, sym_names, sym_err)); }, + "point symmetry of site in Schoenflies notation") .def_property("ion", &cfpars::get_name, &cfpars::set_name, "ion type. If reset, parameters will be updated by scaling by Stevens factors.") .def_property("J", &cfpars::get_J, &cfpars::set_J, "the total angular momentum quantum number of this multiplet") .def_property_readonly("normalisation", &cfpars::get_normalisation, "normalisation of CF parameters") diff --git a/src/libmcphase/pycfpars.hpp b/src/libmcphase/pycfpars.hpp index 76eb46c..018e769 100644 --- a/src/libmcphase/pycfpars.hpp +++ b/src/libmcphase/pycfpars.hpp @@ -10,6 +10,7 @@ #include "cfpars.hpp" #include +#include namespace py = pybind11; using namespace libMcPhase; diff --git a/src/libmcphase/pyic1ion.cpp b/src/libmcphase/pyic1ion.cpp index 42fdfd9..690d604 100644 --- a/src/libmcphase/pyic1ion.cpp +++ b/src/libmcphase/pyic1ion.cpp @@ -58,10 +58,11 @@ void wrap_ic1ion(py::module &m) { .def("zeeman_hamiltonian", &ic1ion::zeeman_hamiltonian, "the Zeeman Hamiltonian") .def("calculate_boltzmann", &ic1ion::calculate_boltzmann, "") .def("heatcapacity", &ic1ion::heatcapacity, "the heat capacity of the crystal field Hamiltonian in J/mol/K") - .def("magnetisation", [](ic1ion &self, std::vector H, std::vector Hdir, std::vector T, std::string unit) { return self.magnetisation(H, Hdir, T, + .def("magnetisation", [](ic1ion &self, std::vector T, std::vector H, std::vector Hdir, std::string unit) { return self.magnetisation(T, H, Hdir, set_enum(unit, mag_unit_names, "Invalid magnetic unit, must be one of: 'bohr', 'cgs', or 'SI'")); }) .def("susceptibility", [](ic1ion &self, std::vector T, std::vector Hdir, std::string unit) { return self.susceptibility(T, Hdir, set_enum(unit, mag_unit_names, "Invalid magnetic unit, must be one of: 'bohr', 'cgs', or 'SI'")); }) + .def("peaks", &ic1ion::peaks, "list of peaks with intensity in mb/sr") .def("get_states", &ic1ion::get_states, "Gets the list of states for this ion configuration"); } diff --git a/src/singleion/cf1ion.cpp b/src/singleion/cf1ion.cpp index 8a8d4b6..61aa19d 100644 --- a/src/singleion/cf1ion.cpp +++ b/src/singleion/cf1ion.cpp @@ -2,7 +2,7 @@ * * A class for calculating the crystal field Hamiltonian in Russell-Saunders (LS-) coupling. * - * (C) 2018 Duc Le - duc.le@stfc.ac.uk + * (C) 2018-2026 Duc Le - duc.le@stfc.ac.uk * This program is licensed under the GNU General Purpose License, version 3. Please see the LICENSE file */ @@ -13,6 +13,10 @@ namespace libMcPhase { static const std::array, 12> idq = { {{2,2,0,4}, {2,1,1,3}, {4,4,5,13}, {4,3,6,12}, {4,2,7,11}, {4,1,8,10}, {6,6,14,26}, {6,5,15,25}, {6,4,16,24}, {6,3,17,23}, {6,2,18,22}, {6,1,19,21}} }; static const std::array, 3> idq0 = { {{2,2}, {4,9}, {6,20}} }; +static const std::array, 27> ikq = { {{2,-2}, {2,-1}, {2,0}, {2,1}, {2,2}, {4,-4}, {4,-3}, {4,-2}, {4,-1}, + {4,0}, {4,1}, {4,2}, {4,3}, {4,4}, {6,-6}, {6,-5}, {6,-4}, {6,-3}, {6,-2}, {6,-1}, {6,0}, {6,1}, {6,2}, {6,3}, {6,4}, {6,5}, {6,6}} }; + +static const double EDIFDEGEN = 1e-6; // --------------------------------------------------------------------------------------------------------------- // // Setter/getter methods for cfpars class @@ -66,6 +70,31 @@ void cf1ion::fill_upper() { m_hamiltonian(i,j) = std::conj(m_hamiltonian(j,i)); } } + m_upper = true; +} + +void cf1ion::_fill_ham_m(RowMatrixXcd &ham, int k, int q, double val, double rme) { + int dimj = m_J2 + 1; + for (int i=0; i<(dimj-q); i++) { + int mj = 2*i - m_J2, mjp = 2*(i+q) - m_J2; + double tjp = m_racah.threej(m_J2, 2*k, m_J2, -mj, 2*q, mjp) - m_racah.threej(m_J2, 2*k, m_J2, -mj, -2*q, mjp); + ham(i+q,i) += std::complex(0., pow(-1., (m_J2-mj)/2.) * tjp * rme * val * m_econv); + } +} +void cf1ion::_fill_ham_p(RowMatrixXcd &ham, int k, int q, double val, double rme) { + int dimj = m_J2 + 1; + for (int i=0; i<(dimj-q); i++) { + int mj = 2*i - m_J2, mjp = 2*(i+q) - m_J2; + double tjp = m_racah.threej(m_J2, 2*k, m_J2, -mj, 2*q, mjp) + m_racah.threej(m_J2, 2*k, m_J2, -mj, -2*q, mjp); + ham(i+q,i) += pow(-1., (m_J2-mj)/2.) * tjp * rme * val * m_econv; + } +} +void cf1ion::_fill_ham_0(RowMatrixXcd &ham, int k, double val, double rme) { + int dimj = m_J2 + 1; + for (int i=0; i 1e-12) { - for (int i=0; i 1e-12) + _fill_ham_0(m_hamiltonian, iq[0], m_Bi[iq[1]], rme[iq[0]]); } // Now the off-diagonal terms - using a helper vector defined globally above to index for (auto iq: idq) { int k = iq[0], q = iq[1], m = iq[2], p = iq[3]; if (std::fabs(m_Bi[m]) > 1e-12) { - for (int i=0; i<(dimj-q); i++) { - int mj = 2*i - m_J2, mjp = 2*(i+q) - m_J2; - double tjp = m_racah.threej(m_J2, 2*k, m_J2, -mj, 2*q, mjp) - m_racah.threej(m_J2, 2*k, m_J2, -mj, -2*q, mjp); - m_hamiltonian(i+q,i) += std::complex(0., pow(-1., (m_J2-mj)/2.) * tjp * rme[k] * m_Bi[m] * m_econv); - } + _fill_ham_m(m_hamiltonian, k, q, m_Bi[m], rme[k]); } if (std::fabs(m_Bi[p]) > 1e-12) { - for (int i=0; i<(dimj-q); i++) { - int mj = 2*i - m_J2, mjp = 2*(i+q) - m_J2; - double tjp = m_racah.threej(m_J2, 2*k, m_J2, -mj, 2*q, mjp) + m_racah.threej(m_J2, 2*k, m_J2, -mj, -2*q, mjp); - m_hamiltonian(i+q,i) += pow(-1., (m_J2-mj)/2.) * tjp * rme[k] * m_Bi[p] * m_econv; - } + _fill_ham_p(m_hamiltonian, k, q, m_Bi[p], rme[k]); } } @@ -174,7 +191,6 @@ RowMatrixXcd cf1ion::_hamiltonian(bool upper) { } m_ham_calc = true; - m_upper = upper; return m_hamiltonian; } @@ -184,7 +200,8 @@ RowMatrixXcd cf1ion::hamiltonian() { std::tuple cf1ion::eigensystem() { if (!m_ev_calc) { - SelfAdjointEigenSolver es(_hamiltonian(false)); + if (!m_ham_calc) _hamiltonian(false); + SelfAdjointEigenSolver es(m_hamiltonian); m_eigenvectors = es.eigenvectors(); m_eigenvalues = es.eigenvalues(); m_ev_calc = true; @@ -254,4 +271,143 @@ std::vector cf1ion::calculate_moments_matrix(RowMatrixXcd ev) { return moments; } +std::vector cf1ion::_set_pars(bool use_sym, bool use_rand) { + m_ham_calc = false; + std::vector nnz; + if (use_rand) { + std::srand(static_cast(std::time({}))); } + if (use_sym) { + int sy = (int)m_sym/10; + for (int id=0; id<27; id++) { + if (BLM_SYM[id] & SYM_CLASS[sy]) { + nnz.push_back(id); + m_Bi[id] = (use_rand ? 2*float(std::rand()/RAND_MAX)-1. : 1.) / (lambda[id] * FABINORM[m_J2][id]); + } else { + m_Bi[id] = 0.; + } + } + } else { + for (int id=0; id<27; id++) { + if (m_Bi[id] != 0.0) { + nnz.push_back(id); + m_Bi[id] = 1. / (lambda[id] * FABINORM[m_J2][id]); + } + } + } + return nnz; +} + +std::vector cf1ion::split2range(double energy_splitting, bool use_sym, bool reset_pars) { + std::vector nnz = _set_pars(use_sym); + SelfAdjointEigenSolver es(_hamiltonian()); + double splitting_factor = 2. * energy_splitting / (es.eigenvalues().maxCoeff() - es.eigenvalues().minCoeff()); + std::vector rv; + for (auto id: nnz) { + rv.push_back(fabs(splitting_factor / FABINORM[m_J2][id])); + } + if (reset_pars) { + for (int id=0; id<27; id++) { + m_Bo[id] = m_Bi[id] * m_convfact[id] * m_econv; } + } else { + for (int id=0; id<27; id++) { + m_Bi[id] = m_Bo[id] / m_convfact[id] / m_econv; } + m_ham_calc = false; + } + m_ev_calc = false; + return rv; +} + +void cf1ion::fitengy(std::vector E_in, bool use_sym) { + size_t dimj = m_J2 + 1; + std::vector nnz; + if (use_sym) { + nnz = _set_pars(true, true); + } else { + for (int id=0; id<27; id++) if (m_Bi[id] != 0.0) nnz.push_back(id); + } + // Computes current eigensystem to get reference energies + SelfAdjointEigenSolver es(_hamiltonian()); + VectorXd Ecalc = es.eigenvalues(); + double ein_min = *(std::min_element(Ecalc.begin(), Ecalc.end())); + std::transform(Ecalc.begin(), Ecalc.end(), Ecalc.begin(), [ein_min](double v) { return v - ein_min; }); + VectorXd E0 = Ecalc; + if (E_in.size() < dimj) { + double anydif = std::accumulate(E_in.begin(), E_in.end(), E_in[0]-1., [](double a, double b) { + return std::isnan(a) ? NAN : (fabs(a-b) idx; + for (int i=0; i Edif(dimj, 0.0); + for (auto en: E_in) { + std::transform(Ecalc.begin(), Ecalc.end(), Edif.begin(), + [en](double v) { return fabs(v - en); }); + auto Idif = std::min_element(idx.begin(), idx.end(), + [Edif](std::pair a, std::pair b) { return Edif[a.first] < Edif[b.first]; }); + if (std::isnan(anydif)) { // There are degeneracies in E_in, treat degenerate calculated levels separately + E0[(*Idif).first] = en; + idx.erase(Idif); + } else { // No degeneracies in E_in, get degeneracies from Ecalc + double Eref = Edif[(*Idif).first]; + for (auto i=idx.begin(); i!=idx.end(); ) { + if (fabs(Edif[(*i).first] - Eref) < EDIFDEGEN) { + E0[(*i).first] = en; + i = idx.erase(i); + } else { + i++; + } + } + } + } + double emean = std::accumulate(E0.begin(), E0.end(), 0.0) / E0.size(); + std::transform(E0.begin(), E0.end(), E0.begin(), [emean](double v) { return v - emean; }); + } else { + double emean = std::accumulate(E_in.begin(), E_in.end(), 0.0) / E0.size(); + std::transform(E_in.begin(), E_in.end(), E0.begin(), [emean](double v) { return v - emean; }); + } + // Computes the Stevens operator matrices for non-zero Blm + std::array rme{}; + for (int k=2; k<=6; k+=2) { + rme[k] = (m_J2 > k) ? pow(2., -k) * sqrt( m_racah.f(m_J2 + k + 1) / m_racah.f(m_J2 - k) ) : 0.; + } + std::vector Omat; + std::vector denom; + for (auto id: nnz) { + RowMatrixXcd ham = RowMatrixXcd::Zero(dimj, dimj); + if (ikq[id][1] < 0) { + _fill_ham_m(ham, ikq[id][0], ikq[id][1], 1.0, rme[ikq[id][0]]); } + else if (ikq[id][1] > 0) { + _fill_ham_p(ham, ikq[id][0], ikq[id][1], 1.0, rme[ikq[id][0]]); } + else { + _fill_ham_0(ham, ikq[id][0], 1.0, rme[ikq[id][0]]); } + for (int i=0; i(EV).begin(), std::get<1>(EV).end(), E0.begin(), 0.0, + std::plus(), [](double a, double b) { return pow(a - b, 2.); }); + if (fabs(lsqfit - newlsq) < 1e-7) { + break; } + if (newlsq > lsqfit) { + if (++div_count > 10) { // Diverging fit, break + break; } } + lsqfit = newlsq; + for (int i=0; i(EV).adjoint() * Omat[i] * std::get<0>(EV)).diagonal().cwiseProduct(E0).sum().real(); + m_Bi[nnz[i]] = numer / denom[i]; + } + } + for (int id=0; id<27; id++) { + m_Bo[id] = m_Bi[id] * m_convfact[id] * m_econv; } +} + } // namespace libMcPhase diff --git a/src/singleion/cfpars.cpp b/src/singleion/cfpars.cpp index d345943..6f7c1b1 100644 --- a/src/singleion/cfpars.cpp +++ b/src/singleion/cfpars.cpp @@ -2,7 +2,7 @@ * * A class encapsulating crystal field parameters and their conversions * - * (C) 2018 Duc Le - duc.le@stfc.ac.uk + * (C) 2018-2026 Duc Le - duc.le@stfc.ac.uk * This program is licensed under the GNU General Purpose License, version 3. Please see the LICENSE file */ @@ -14,13 +14,6 @@ namespace libMcPhase { // Reference tables (values taken from program cfield, by Peter Fabi, FZ Juelich, file theta.c) // --------------------------------------------------------------------------------------------------------------- // -// Conversion factors from Stevens to Wybourn normalisation -static const std::array lambda = { - {sqrt(6.)/2., sqrt(6.), 1./2., sqrt(6.), sqrt(6.)/2., // l=2 - sqrt(70.)/8., sqrt(35.)/2., sqrt(10.)/4., sqrt(5.)/2., 1./8., sqrt(5.)/2., sqrt(10.)/4., sqrt(35.)/2., sqrt(70.)/8., // l=4 - sqrt(231.)/16., 3*sqrt(77.)/8., 3*sqrt(14.)/16., sqrt(105.)/8., sqrt(105.)/16., sqrt(42.)/8., // l=6, m=-6 to m=-1 - 1./16., sqrt(42.)/8., sqrt(105.)/16., sqrt(105.)/8., 3*sqrt(14.)/16., 3*sqrt(77.)/8., sqrt(231.)/16.} }; - static const std::array id2l = { {0,0,0,0,0, 1,1,1,1,1,1,1,1,1, 2,2,2,2,2,2,2,2,2,2,2,2,2} }; // Matching ion names to number of unfilled electrons in f-shell @@ -151,10 +144,25 @@ void cfpars::getfromionname(const std::string &ionname) { m_rk = rk_table->second; } +bool cfpars::is_sym_allowed(const Blm blm) { + return BLM_SYM[(int)blm] & SYM_CLASS[(int)m_sym/10]; +} + +std::vector cfpars::get_sym_allowed_Blm() { + std::vector rv; + int sy = (int)m_sym/10; + for (int i=0; i<27; i++) { + if (BLM_SYM[i] & SYM_CLASS[sy]) rv.push_back(static_cast(i)); + } + return rv; +} + // --------------------------------------------------------------------------------------------------------------- // // Setter/getter methods for cfpars class // --------------------------------------------------------------------------------------------------------------- // void cfpars::set(const Blm blm, double val) { + if (!is_sym_allowed(blm)) { + throw std::runtime_error("cfpars::set() Parameter not allowed by symmetry"); } int id = (int)blm; m_Bo[id] = val; m_Bi[id] = val / m_convfact[id] / m_econv; @@ -169,6 +177,8 @@ void cfpars::set(int l, int m, double val) { default: return; } + if (!is_sym_allowed(static_cast(id))) { + throw std::runtime_error("cfpars::set() Parameter not allowed by symmetry"); } m_Bo[id] = val; m_Bi[id] = val / m_convfact[id] / m_econv; } @@ -217,6 +227,10 @@ void cfpars::set_type(const cfpars::Type newtype) { if(m_stevfact[id2l[id]] != 0) m_convfact[id] = 1. / m_stevfact[id2l[id]]; break; + case cfpars::Type::Nlm: + for (int id=0; id<27; id++) + m_convfact[id] = lambda[id] * FABINORM[m_J2][id]; + break; } for (int id=0; id<27; id++) m_Bo[id] = m_Bi[id] * m_convfact[id] * m_econv; diff --git a/src/singleion/ic1ion.cpp b/src/singleion/ic1ion.cpp index 8622845..d1b8890 100644 --- a/src/singleion/ic1ion.cpp +++ b/src/singleion/ic1ion.cpp @@ -126,6 +126,8 @@ void ic1ion::set_coulomb(const std::vector val, ic1ion::CoulombType type break; } std::transform(m_F.begin(), m_F.end(), m_F_i.begin(), [=](double v) { return v / m_econv; }); + m_ham_calc = false; + m_ev_calc = false; } void ic1ion::set_ci(std::vector val) { @@ -135,6 +137,8 @@ void ic1ion::set_ci(std::vector val) { } std::copy(val.begin(), val.end(), m_alpha.begin()); std::transform(val.begin(), val.end(), m_alpha_i.begin(), [=](double v) { return v / m_econv; }); + m_ham_calc = false; + m_ev_calc = false; } void ic1ion::set_spinorbit(double val, ic1ion::SpinOrbType type) { diff --git a/src/singleion/physprop.cpp b/src/singleion/physprop.cpp index 5a9e060..30bf335 100644 --- a/src/singleion/physprop.cpp +++ b/src/singleion/physprop.cpp @@ -3,7 +3,7 @@ * A class for calculating the physical properties (magnetisation, susceptibility, heat capacity) associated with * a crystal field type single-ion Hamiltonian. * - * (C) 2024 Duc Le - duc.le@stfc.ac.uk + * (C) 2024-2026 Duc Le - duc.le@stfc.ac.uk * This program is licensed under the GNU General Purpose License, version 3. Please see the LICENSE file */ @@ -60,7 +60,7 @@ VectorXd physprop::heatcapacity(std::vector Tvec) { return out; } -RowMatrixXd physprop::magnetisation(std::vector Hvec, std::vector Hdir, std::vector Tvec, MagUnits unit_type) +RowMatrixXd physprop::magnetisation(std::vector Tvec, std::vector Hvec, std::vector Hdir, MagUnits unit_type) { // Normalise the field direction vector double Hnorm = sqrt(Hdir[0] * Hdir[0] + Hdir[1] * Hdir[1] + Hdir[2] * Hdir[2]); @@ -152,4 +152,54 @@ VectorXd physprop::susceptibility(std::vector Tvec, std::vector return chi; } +RowMatrixXd physprop::peaks(double T) +{ + auto es = eigensystem(); + std::vector moments_mat_vec = calculate_moments_matrix(std::get<0>(es)); + RowMatrixXcd trans = moments_mat_vec[0].cwiseProduct(moments_mat_vec[0].conjugate()) + + moments_mat_vec[1].cwiseProduct(moments_mat_vec[1].conjugate()) + + moments_mat_vec[2].cwiseProduct(moments_mat_vec[2].conjugate()); + size_t sz = std::get<1>(es).size(); + double Z = 0.; + VectorXd expfact = calculate_boltzmann(std::get<1>(es), T); + for (size_t i=0; i < sz; i++) { + Z += expfact[i]; + trans.col(i) *= expfact[i]; + } + trans *= MAGXSEC_MBSR / Z; // The magnetic cross-section in milibarn/sr + // Match transition matrix elements to energies + std::vector< std::pair > pkl; + pkl.reserve(sz * sz); + for (int i=0; i 1e-6) { + pkl.push_back(std::make_pair(std::get<1>(es)[i] - std::get<1>(es)[j], trans(i,j).real())); + } + } + } + // Sums degenerate transitions + std::sort(pkl.begin(), pkl.end(), + [](std::pair a, std::pair b) { return a.first > b.first; }); + std::vector ndegen; + int n_ex = 0, j = 0; + ndegen.reserve(pkl.size()); + ndegen.push_back(j); + for (int i=1; i pkl[b].second; }); + for (int i=0; i { + let pyodide = await loadPyodide({ + indexURL: "node_modules/pyodide", + }); + await pyodide.loadPackage("numpy") + const wheels = await glob("dist/*whl"); + for (const wheel of wheels) { + await pyodide.loadPackage(wheel); } + console.log("Loaded Pyodide and wheels"); + pyodide.mountNodeFS("/mnt", "tests"); + global.pyodide = pyodide; +}; diff --git a/tests/test.js b/tests/test.js new file mode 100644 index 0000000..03a1b62 --- /dev/null +++ b/tests/test.js @@ -0,0 +1,45 @@ +beforeAll(() => { + global.pyodide.runPython(` + import importlib.util + from importlib.machinery import SourceFileLoader + import os + import sys + import unittest + from unittest.mock import patch + + def run_test(testname): + pathname = f"/mnt/{testname}.py" + if not os.path.exists(pathname): + raise ValueError(f"Test file {testname} not found") + test_module_name = os.path.splitext(os.path.basename(pathname))[0] + test_loader = SourceFileLoader(test_module_name, pathname) + test_spec = importlib.util.spec_from_loader(test_module_name, test_loader) + test_module = importlib.util.module_from_spec(test_spec) + test_loader.exec_module(test_module) + test_module_globals = dir(test_module) + this_globals = globals() + for key in test_module_globals: + this_globals[key] = getattr(test_module, key) + + # create runner & execute + print(f'Running {testname}') + with patch('sys.exit') as exit_call: + unittest.main( + module=test_module, + # We've processed the test source so don't let unittest try to reparse it + # This forces it to load the tests from the supplied module + argv=(sys.argv[0],), + # these make sure that some options that are not applicable + # remain hidden from the help menu. + failfast=False, + buffer=False, + catchbreak=False, + ) + # On success, unittest exits with code 0. Code 1 on failure + exit_call.assert_called_with(0) + `); +}); + +test("test_cfpars.py", () => { let result = global.pyodide.runPython(` run_test("test_cfpars") `); }); +test("test_cf1ion.py", () => { let result = global.pyodide.runPython(` run_test("test_cf1ion") `); }); +test("test_ic1ion.py", () => { let result = global.pyodide.runPython(` run_test("test_ic1ion") `); }); diff --git a/tests/test_cf1ion.py b/tests/test_cf1ion.py index 20f7199..315d121 100644 --- a/tests/test_cf1ion.py +++ b/tests/test_cf1ion.py @@ -126,7 +126,7 @@ def test_magnetisation_vs_T(self): tt = np.linspace(1, 300, 50) #Tmt_powder, mt_powder = cf.getMagneticMoment(1.0, Temperature=np.linspace(1, 300, 50), Hdir="powder", Unit="cgs") cc = [cf.susceptibility(tt, hdir, 'cgs') for hdir in [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]] - mm = [cf.magnetisation([1.0], hdir, tt, 'cgs') for hdir in [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]] + mm = [cf.magnetisation(tt, [1.0], hdir, 'cgs') for hdir in [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]] chi_powder = (cc[0] + cc[1] + cc[2]) / 3 mt_powder = np.squeeze(mm[0] + mm[1] + mm[2]) / 3 self.assertAlmostEqual(chi_powder[5], mt_powder[5], 6) @@ -139,13 +139,13 @@ def test_magnetisation_vs_T(self): # Test different Hmag #_, h_mag_10 = cf.getMagneticMoment(Hmag=10, Temperature=np.linspace(1, 300, 50), Hdir="powder", Unit="bohr") - mm = [cf.magnetisation([10.], hdir, tt, 'bohr') for hdir in [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]] + mm = [cf.magnetisation(tt, [10.], hdir, 'bohr') for hdir in [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]] h_mag_10 = np.squeeze(mm[0] + mm[1] + mm[2]) / 3 self.assertAlmostEqual(h_mag_10[5], 0.323607, 5) self.assertAlmostEqual(h_mag_10[10], 0.182484, 5) self.assertAlmostEqual(h_mag_10[15], 0.129909, 5) #_, h_mag_5 = cf.getMagneticMoment(Hmag=5, Temperature=np.linspace(1, 300, 50), Hdir="powder", Unit="bohr") - mm = [cf.magnetisation([5.], hdir, tt, 'bohr') for hdir in [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]] + mm = [cf.magnetisation(tt, [5.], hdir, 'bohr') for hdir in [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]] h_mag_5 = np.squeeze(mm[0] + mm[1] + mm[2]) / 3 self.assertAlmostEqual(h_mag_5[5], 0.16923426, 6) self.assertAlmostEqual(h_mag_5[10], 0.09228022, 6) @@ -155,12 +155,36 @@ def test_magnetisation(self): # Test M(H) calculations cf = libmcphase.cf1ion('Ce3+', **self.pp_cfpars) #Hmag_SI, mag_SI = cf.getMagneticMoment(np.linspace(0, 30, 15), Temperature=10, Hdir=[0, 1, -1], Unit="SI") - mag_SI = np.squeeze(cf.magnetisation(np.linspace(0, 30, 15), [0, 1, -1], [10], 'SI')) + mag_SI = np.squeeze(cf.magnetisation([10], np.linspace(0, 30, 15), [0, 1, -1], 'SI')) self.assertAlmostEqual(mag_SI[1], 1.8139, 3) self.assertAlmostEqual(mag_SI[5], 6.7859, 3) self.assertAlmostEqual(mag_SI[9], 8.2705, 3) #_, mag_bohr = cf.getMagneticMoment(np.linspace(0, 30, 15), Temperature=10, Hdir=[0, 1, -1], Unit="bohr") - mag_bohr = np.squeeze(cf.magnetisation(np.linspace(0, 30, 15), [0, 1, -1], [10], 'bohr')) + mag_bohr = np.squeeze(cf.magnetisation([10], np.linspace(0, 30, 15), [0, 1, -1], 'bohr')) self.assertAlmostEqual(mag_SI[1] / 5.5849, mag_bohr[1], 3) self.assertAlmostEqual(mag_SI[5] / 5.5849, mag_bohr[5], 3) self.assertAlmostEqual(mag_SI[9] / 5.5849, mag_bohr[9], 3) + + def test_peaks_upd3(self): + cfp = libmcphase.cf1ion('Pr3+', type='Blm', B20=0.035, B40=-0.012, B43=-0.027, B60=-0.00012, B63=0.0025, B66=0.0068) + ref_mantid = np.array([[30.0265, 210.2884], [0., 183.5082], [20.6513, 126.348], [9.6356, 76.4194], [4.3651, 19.3257], [52.4979, 2.1114]]) + nptest.assert_allclose(cfp.peaks(1), ref_mantid, atol=1e-3) + + def test_norm_split2range(self): + ref_mantid = [0.7299684691827522, 0.014315859494885794, 0.23955014769698493, 0.0006854843972749612, 0.009933612654546054, 0.007366964314003879] + ref_E = [0., 0., 4.3651248452, 9.6355538971, 9.6355538971, 20.6512567727, 30.0265185296, 30.0265185296, 52.4978908089] + cf = libmcphase.cf1ion('Pr3+', sym='C3v', B20=0.035, B40=-0.012, B43=-0.027, B60=-0.00012, B63=0.0025, B66=0.0068) + nptest.assert_allclose(cf.split2range(50, True), ref_mantid, atol=1e-3) + V, E = cf.eigensystem() + nptest.assert_allclose(E - np.min(E), ref_E, atol=1e-3) + + def test_fitengy(self): + # Test values from Mantid function + ref1 = [0.033203742032045895, -0.01174207044845451, -0.02606886438909303, -0.00012163307624938078, 0.0022326316235320837, 0.006886821595013801] + ref2 = [0.055185081912631335, -0.008744257519347313, -0.0880384277475906, -0.00014477480672137673, 0.0005308760990602457, 0.007381916019568393] + cf = libmcphase.cf1ion('Pr3+', sym='C3v', B20=0.035, B40=-0.012, B43=-0.027, B60=-0.00012, B63=0.0025, B66=0.0068) + cf.fitengy([0, 5, 10, 20], False) + nptest.assert_allclose([getattr(cf, blm) for blm in ['B20', 'B40', 'B43', 'B60', 'B63', 'B66']], ref1, atol=1e-3) + cf.fitengy([0, 5, 10, 20, 20], False) + nptest.assert_allclose([getattr(cf, blm) for blm in ['B20', 'B40', 'B43', 'B60', 'B63', 'B66']], ref2, atol=1e-3) + diff --git a/tests/test_ic1ion.py b/tests/test_ic1ion.py index 9166bc1..41b26b1 100644 --- a/tests/test_ic1ion.py +++ b/tests/test_ic1ion.py @@ -72,7 +72,7 @@ def test_magnetisation(self): # Test compared to McPhase 5.4 (using m_parallel) ref_mag = np.array([0, 0.297508, 0.58146, 0.841784, 1.07343, 1.27577, 1.45094, 1.6023, 1.73344, 1.84766, 1.94775]) cfp = libmcphase.ic1ion('Pr3+', **self.all_pars) - mag = np.squeeze(cfp.magnetisation(np.arange(0, 21, 2), [1, 0, 0], [1], 'bohr')) + mag = np.squeeze(cfp.magnetisation([1], np.arange(0, 21, 2), [1, 0, 0], 'bohr')) nptest.assert_allclose(mag, ref_mag, atol=1e-4) def test_susceptibility(self): @@ -86,7 +86,7 @@ def test_magnetisation_cf(self): # Test M(H) calculations in the LS-limit (compare with Mantid output) cf = libmcphase.ic1ion('Ce3+', **self.pp_cfpars) #Hmag_SI, mag_SI = cf.getMagneticMoment(np.linspace(0, 30, 15), Temperature=10, Hdir=[0, 1, -1], Unit="SI") - mag_SI = np.squeeze(cf.magnetisation(np.linspace(0, 30, 15), [0, 1, -1], [10], 'SI')) + mag_SI = np.squeeze(cf.magnetisation([10], np.linspace(0, 30, 15), [0, 1, -1], 'SI')) self.assertAlmostEqual(mag_SI[1], 1.8139, 2) self.assertAlmostEqual(mag_SI[5], 6.7859, 2) self.assertAlmostEqual(mag_SI[9], 8.2705, 2) @@ -101,19 +101,29 @@ def test_susc_mt_cf(self): self.assertAlmostEqual(chi_powder[10], 1.03471e-2, 3) self.assertAlmostEqual(chi_powder[15], 0.73004e-2, 3) # Test susceptibility and M(T) calculations similar in the limit of small applied fields - mm = [cf.magnetisation([1.0], hdir, tt, 'cgs') for hdir in [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]] + mm = [cf.magnetisation(tt, [1.0], hdir, 'cgs') for hdir in [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]] mt_powder = np.squeeze(mm[0] + mm[1] + mm[2]) / 3 self.assertAlmostEqual(chi_powder[5], mt_powder[5], 3) self.assertAlmostEqual(chi_powder[10], mt_powder[10], 3) self.assertAlmostEqual(chi_powder[15], mt_powder[15], 3) # Test different Hmag - mm = [cf.magnetisation([10.], hdir, tt, 'bohr') for hdir in [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]] + mm = [cf.magnetisation(tt, [10.], hdir, 'bohr') for hdir in [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]] h_mag_10 = np.squeeze(mm[0] + mm[1] + mm[2]) / 3 self.assertAlmostEqual(h_mag_10[5], 0.323607, 3) self.assertAlmostEqual(h_mag_10[10], 0.182484, 3) self.assertAlmostEqual(h_mag_10[15], 0.129909, 3) - mm = [cf.magnetisation([5.], hdir, tt, 'bohr') for hdir in [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]] + mm = [cf.magnetisation(tt, [5.], hdir, 'bohr') for hdir in [[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]]] h_mag_5 = np.squeeze(mm[0] + mm[1] + mm[2]) / 3 self.assertAlmostEqual(h_mag_5[5], 0.16923426, 3) self.assertAlmostEqual(h_mag_5[10], 0.09228022, 3) self.assertAlmostEqual(h_mag_5[15], 0.06525625, 3) + + def test_peaks_upd3(self): + ref_mantid = np.array([[30.0265, 210.2884], [0., 183.5082], [20.6513, 126.348], [9.6356, 76.4194], [4.3651, 19.3257], [52.4979, 2.1114]]) + ref_mcphase = np.array([[6.5616, 609.072], [666.548, 36.7447], [0.6159, 26.8386], [678.999, 18.8735], [41.4857, 10.977 ], [1061.59, 4.1365], [22.9592, 1.3436]]) + cfp = libmcphase.ic1ion('U4+', type='Blm', B20=0.035, B40=-0.012, B43=-0.027, B60=-0.00012, B63=0.0025, B66=0.0068) + np.testing.assert_allclose(cfp.peaks(1)[:7,:], ref_mcphase, atol=0.5, rtol=0.05) + cfp.set_coulomb([1e13, 1e13, 1e13], 'Slater') + cfp.set_spinorbit(1e9, 'Zeta') + pkl = cfp.peaks(1) + np.testing.assert_allclose(pkl[np.where( (pkl[:,0] < 200) * (pkl[:,1] > 1) )[0],:], ref_mantid, atol=0.5, rtol=0.05) diff --git a/versioneer.py b/versioneer.py deleted file mode 100644 index 1e3753e..0000000 --- a/versioneer.py +++ /dev/null @@ -1,2277 +0,0 @@ - -# Version: 0.29 - -"""The Versioneer - like a rocketeer, but for versions. - -The Versioneer -============== - -* like a rocketeer, but for versions! -* https://github.com/python-versioneer/python-versioneer -* Brian Warner -* License: Public Domain (Unlicense) -* Compatible with: Python 3.7, 3.8, 3.9, 3.10, 3.11 and pypy3 -* [![Latest Version][pypi-image]][pypi-url] -* [![Build Status][travis-image]][travis-url] - -This is a tool for managing a recorded version number in setuptools-based -python projects. The goal is to remove the tedious and error-prone "update -the embedded version string" step from your release process. Making a new -release should be as easy as recording a new tag in your version-control -system, and maybe making new tarballs. - - -## Quick Install - -Versioneer provides two installation modes. The "classic" vendored mode installs -a copy of versioneer into your repository. The experimental build-time dependency mode -is intended to allow you to skip this step and simplify the process of upgrading. - -### Vendored mode - -* `pip install versioneer` to somewhere in your $PATH - * A [conda-forge recipe](https://github.com/conda-forge/versioneer-feedstock) is - available, so you can also use `conda install -c conda-forge versioneer` -* add a `[tool.versioneer]` section to your `pyproject.toml` or a - `[versioneer]` section to your `setup.cfg` (see [Install](INSTALL.md)) - * Note that you will need to add `tomli; python_version < "3.11"` to your - build-time dependencies if you use `pyproject.toml` -* run `versioneer install --vendor` in your source tree, commit the results -* verify version information with `python setup.py version` - -### Build-time dependency mode - -* `pip install versioneer` to somewhere in your $PATH - * A [conda-forge recipe](https://github.com/conda-forge/versioneer-feedstock) is - available, so you can also use `conda install -c conda-forge versioneer` -* add a `[tool.versioneer]` section to your `pyproject.toml` or a - `[versioneer]` section to your `setup.cfg` (see [Install](INSTALL.md)) -* add `versioneer` (with `[toml]` extra, if configuring in `pyproject.toml`) - to the `requires` key of the `build-system` table in `pyproject.toml`: - ```toml - [build-system] - requires = ["setuptools", "versioneer[toml]"] - build-backend = "setuptools.build_meta" - ``` -* run `versioneer install --no-vendor` in your source tree, commit the results -* verify version information with `python setup.py version` - -## Version Identifiers - -Source trees come from a variety of places: - -* a version-control system checkout (mostly used by developers) -* a nightly tarball, produced by build automation -* a snapshot tarball, produced by a web-based VCS browser, like github's - "tarball from tag" feature -* a release tarball, produced by "setup.py sdist", distributed through PyPI - -Within each source tree, the version identifier (either a string or a number, -this tool is format-agnostic) can come from a variety of places: - -* ask the VCS tool itself, e.g. "git describe" (for checkouts), which knows - about recent "tags" and an absolute revision-id -* the name of the directory into which the tarball was unpacked -* an expanded VCS keyword ($Id$, etc) -* a `_version.py` created by some earlier build step - -For released software, the version identifier is closely related to a VCS -tag. Some projects use tag names that include more than just the version -string (e.g. "myproject-1.2" instead of just "1.2"), in which case the tool -needs to strip the tag prefix to extract the version identifier. For -unreleased software (between tags), the version identifier should provide -enough information to help developers recreate the same tree, while also -giving them an idea of roughly how old the tree is (after version 1.2, before -version 1.3). Many VCS systems can report a description that captures this, -for example `git describe --tags --dirty --always` reports things like -"0.7-1-g574ab98-dirty" to indicate that the checkout is one revision past the -0.7 tag, has a unique revision id of "574ab98", and is "dirty" (it has -uncommitted changes). - -The version identifier is used for multiple purposes: - -* to allow the module to self-identify its version: `myproject.__version__` -* to choose a name and prefix for a 'setup.py sdist' tarball - -## Theory of Operation - -Versioneer works by adding a special `_version.py` file into your source -tree, where your `__init__.py` can import it. This `_version.py` knows how to -dynamically ask the VCS tool for version information at import time. - -`_version.py` also contains `$Revision$` markers, and the installation -process marks `_version.py` to have this marker rewritten with a tag name -during the `git archive` command. As a result, generated tarballs will -contain enough information to get the proper version. - -To allow `setup.py` to compute a version too, a `versioneer.py` is added to -the top level of your source tree, next to `setup.py` and the `setup.cfg` -that configures it. This overrides several distutils/setuptools commands to -compute the version when invoked, and changes `setup.py build` and `setup.py -sdist` to replace `_version.py` with a small static file that contains just -the generated version data. - -## Installation - -See [INSTALL.md](./INSTALL.md) for detailed installation instructions. - -## Version-String Flavors - -Code which uses Versioneer can learn about its version string at runtime by -importing `_version` from your main `__init__.py` file and running the -`get_versions()` function. From the "outside" (e.g. in `setup.py`), you can -import the top-level `versioneer.py` and run `get_versions()`. - -Both functions return a dictionary with different flavors of version -information: - -* `['version']`: A condensed version string, rendered using the selected - style. This is the most commonly used value for the project's version - string. The default "pep440" style yields strings like `0.11`, - `0.11+2.g1076c97`, or `0.11+2.g1076c97.dirty`. See the "Styles" section - below for alternative styles. - -* `['full-revisionid']`: detailed revision identifier. For Git, this is the - full SHA1 commit id, e.g. "1076c978a8d3cfc70f408fe5974aa6c092c949ac". - -* `['date']`: Date and time of the latest `HEAD` commit. For Git, it is the - commit date in ISO 8601 format. This will be None if the date is not - available. - -* `['dirty']`: a boolean, True if the tree has uncommitted changes. Note that - this is only accurate if run in a VCS checkout, otherwise it is likely to - be False or None - -* `['error']`: if the version string could not be computed, this will be set - to a string describing the problem, otherwise it will be None. It may be - useful to throw an exception in setup.py if this is set, to avoid e.g. - creating tarballs with a version string of "unknown". - -Some variants are more useful than others. Including `full-revisionid` in a -bug report should allow developers to reconstruct the exact code being tested -(or indicate the presence of local changes that should be shared with the -developers). `version` is suitable for display in an "about" box or a CLI -`--version` output: it can be easily compared against release notes and lists -of bugs fixed in various releases. - -The installer adds the following text to your `__init__.py` to place a basic -version in `YOURPROJECT.__version__`: - - from ._version import get_versions - __version__ = get_versions()['version'] - del get_versions - -## Styles - -The setup.cfg `style=` configuration controls how the VCS information is -rendered into a version string. - -The default style, "pep440", produces a PEP440-compliant string, equal to the -un-prefixed tag name for actual releases, and containing an additional "local -version" section with more detail for in-between builds. For Git, this is -TAG[+DISTANCE.gHEX[.dirty]] , using information from `git describe --tags ---dirty --always`. For example "0.11+2.g1076c97.dirty" indicates that the -tree is like the "1076c97" commit but has uncommitted changes (".dirty"), and -that this commit is two revisions ("+2") beyond the "0.11" tag. For released -software (exactly equal to a known tag), the identifier will only contain the -stripped tag, e.g. "0.11". - -Other styles are available. See [details.md](details.md) in the Versioneer -source tree for descriptions. - -## Debugging - -Versioneer tries to avoid fatal errors: if something goes wrong, it will tend -to return a version of "0+unknown". To investigate the problem, run `setup.py -version`, which will run the version-lookup code in a verbose mode, and will -display the full contents of `get_versions()` (including the `error` string, -which may help identify what went wrong). - -## Known Limitations - -Some situations are known to cause problems for Versioneer. This details the -most significant ones. More can be found on Github -[issues page](https://github.com/python-versioneer/python-versioneer/issues). - -### Subprojects - -Versioneer has limited support for source trees in which `setup.py` is not in -the root directory (e.g. `setup.py` and `.git/` are *not* siblings). The are -two common reasons why `setup.py` might not be in the root: - -* Source trees which contain multiple subprojects, such as - [Buildbot](https://github.com/buildbot/buildbot), which contains both - "master" and "slave" subprojects, each with their own `setup.py`, - `setup.cfg`, and `tox.ini`. Projects like these produce multiple PyPI - distributions (and upload multiple independently-installable tarballs). -* Source trees whose main purpose is to contain a C library, but which also - provide bindings to Python (and perhaps other languages) in subdirectories. - -Versioneer will look for `.git` in parent directories, and most operations -should get the right version string. However `pip` and `setuptools` have bugs -and implementation details which frequently cause `pip install .` from a -subproject directory to fail to find a correct version string (so it usually -defaults to `0+unknown`). - -`pip install --editable .` should work correctly. `setup.py install` might -work too. - -Pip-8.1.1 is known to have this problem, but hopefully it will get fixed in -some later version. - -[Bug #38](https://github.com/python-versioneer/python-versioneer/issues/38) is tracking -this issue. The discussion in -[PR #61](https://github.com/python-versioneer/python-versioneer/pull/61) describes the -issue from the Versioneer side in more detail. -[pip PR#3176](https://github.com/pypa/pip/pull/3176) and -[pip PR#3615](https://github.com/pypa/pip/pull/3615) contain work to improve -pip to let Versioneer work correctly. - -Versioneer-0.16 and earlier only looked for a `.git` directory next to the -`setup.cfg`, so subprojects were completely unsupported with those releases. - -### Editable installs with setuptools <= 18.5 - -`setup.py develop` and `pip install --editable .` allow you to install a -project into a virtualenv once, then continue editing the source code (and -test) without re-installing after every change. - -"Entry-point scripts" (`setup(entry_points={"console_scripts": ..})`) are a -convenient way to specify executable scripts that should be installed along -with the python package. - -These both work as expected when using modern setuptools. When using -setuptools-18.5 or earlier, however, certain operations will cause -`pkg_resources.DistributionNotFound` errors when running the entrypoint -script, which must be resolved by re-installing the package. This happens -when the install happens with one version, then the egg_info data is -regenerated while a different version is checked out. Many setup.py commands -cause egg_info to be rebuilt (including `sdist`, `wheel`, and installing into -a different virtualenv), so this can be surprising. - -[Bug #83](https://github.com/python-versioneer/python-versioneer/issues/83) describes -this one, but upgrading to a newer version of setuptools should probably -resolve it. - - -## Updating Versioneer - -To upgrade your project to a new release of Versioneer, do the following: - -* install the new Versioneer (`pip install -U versioneer` or equivalent) -* edit `setup.cfg` and `pyproject.toml`, if necessary, - to include any new configuration settings indicated by the release notes. - See [UPGRADING](./UPGRADING.md) for details. -* re-run `versioneer install --[no-]vendor` in your source tree, to replace - `SRC/_version.py` -* commit any changed files - -## Future Directions - -This tool is designed to make it easily extended to other version-control -systems: all VCS-specific components are in separate directories like -src/git/ . The top-level `versioneer.py` script is assembled from these -components by running make-versioneer.py . In the future, make-versioneer.py -will take a VCS name as an argument, and will construct a version of -`versioneer.py` that is specific to the given VCS. It might also take the -configuration arguments that are currently provided manually during -installation by editing setup.py . Alternatively, it might go the other -direction and include code from all supported VCS systems, reducing the -number of intermediate scripts. - -## Similar projects - -* [setuptools_scm](https://github.com/pypa/setuptools_scm/) - a non-vendored build-time - dependency -* [minver](https://github.com/jbweston/miniver) - a lightweight reimplementation of - versioneer -* [versioningit](https://github.com/jwodder/versioningit) - a PEP 518-based setuptools - plugin - -## License - -To make Versioneer easier to embed, all its code is dedicated to the public -domain. The `_version.py` that it creates is also in the public domain. -Specifically, both are released under the "Unlicense", as described in -https://unlicense.org/. - -[pypi-image]: https://img.shields.io/pypi/v/versioneer.svg -[pypi-url]: https://pypi.python.org/pypi/versioneer/ -[travis-image]: -https://img.shields.io/travis/com/python-versioneer/python-versioneer.svg -[travis-url]: https://travis-ci.com/github/python-versioneer/python-versioneer - -""" -# pylint:disable=invalid-name,import-outside-toplevel,missing-function-docstring -# pylint:disable=missing-class-docstring,too-many-branches,too-many-statements -# pylint:disable=raise-missing-from,too-many-lines,too-many-locals,import-error -# pylint:disable=too-few-public-methods,redefined-outer-name,consider-using-with -# pylint:disable=attribute-defined-outside-init,too-many-arguments - -import configparser -import errno -import json -import os -import re -import subprocess -import sys -from pathlib import Path -from typing import Any, Callable, cast, Dict, List, Optional, Tuple, Union -from typing import NoReturn -import functools - -have_tomllib = True -if sys.version_info >= (3, 11): - import tomllib -else: - try: - import tomli as tomllib - except ImportError: - have_tomllib = False - - -class VersioneerConfig: - """Container for Versioneer configuration parameters.""" - - VCS: str - style: str - tag_prefix: str - versionfile_source: str - versionfile_build: Optional[str] - parentdir_prefix: Optional[str] - verbose: Optional[bool] - - -def get_root() -> str: - """Get the project root directory. - - We require that all commands are run from the project root, i.e. the - directory that contains setup.py, setup.cfg, and versioneer.py . - """ - root = os.path.realpath(os.path.abspath(os.getcwd())) - setup_py = os.path.join(root, "setup.py") - pyproject_toml = os.path.join(root, "pyproject.toml") - versioneer_py = os.path.join(root, "versioneer.py") - if not ( - os.path.exists(setup_py) - or os.path.exists(pyproject_toml) - or os.path.exists(versioneer_py) - ): - # allow 'python path/to/setup.py COMMAND' - root = os.path.dirname(os.path.realpath(os.path.abspath(sys.argv[0]))) - setup_py = os.path.join(root, "setup.py") - pyproject_toml = os.path.join(root, "pyproject.toml") - versioneer_py = os.path.join(root, "versioneer.py") - if not ( - os.path.exists(setup_py) - or os.path.exists(pyproject_toml) - or os.path.exists(versioneer_py) - ): - err = ("Versioneer was unable to run the project root directory. " - "Versioneer requires setup.py to be executed from " - "its immediate directory (like 'python setup.py COMMAND'), " - "or in a way that lets it use sys.argv[0] to find the root " - "(like 'python path/to/setup.py COMMAND').") - raise VersioneerBadRootError(err) - try: - # Certain runtime workflows (setup.py install/develop in a setuptools - # tree) execute all dependencies in a single python process, so - # "versioneer" may be imported multiple times, and python's shared - # module-import table will cache the first one. So we can't use - # os.path.dirname(__file__), as that will find whichever - # versioneer.py was first imported, even in later projects. - my_path = os.path.realpath(os.path.abspath(__file__)) - me_dir = os.path.normcase(os.path.splitext(my_path)[0]) - vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[0]) - if me_dir != vsr_dir and "VERSIONEER_PEP518" not in globals(): - print("Warning: build in %s is using versioneer.py from %s" - % (os.path.dirname(my_path), versioneer_py)) - except NameError: - pass - return root - - -def get_config_from_root(root: str) -> VersioneerConfig: - """Read the project setup.cfg file to determine Versioneer config.""" - # This might raise OSError (if setup.cfg is missing), or - # configparser.NoSectionError (if it lacks a [versioneer] section), or - # configparser.NoOptionError (if it lacks "VCS="). See the docstring at - # the top of versioneer.py for instructions on writing your setup.cfg . - root_pth = Path(root) - pyproject_toml = root_pth / "pyproject.toml" - setup_cfg = root_pth / "setup.cfg" - section: Union[Dict[str, Any], configparser.SectionProxy, None] = None - if pyproject_toml.exists() and have_tomllib: - try: - with open(pyproject_toml, 'rb') as fobj: - pp = tomllib.load(fobj) - section = pp['tool']['versioneer'] - except (tomllib.TOMLDecodeError, KeyError) as e: - print(f"Failed to load config from {pyproject_toml}: {e}") - print("Try to load it from setup.cfg") - if not section: - parser = configparser.ConfigParser() - with open(setup_cfg) as cfg_file: - parser.read_file(cfg_file) - parser.get("versioneer", "VCS") # raise error if missing - - section = parser["versioneer"] - - # `cast`` really shouldn't be used, but its simplest for the - # common VersioneerConfig users at the moment. We verify against - # `None` values elsewhere where it matters - - cfg = VersioneerConfig() - cfg.VCS = section['VCS'] - cfg.style = section.get("style", "") - cfg.versionfile_source = cast(str, section.get("versionfile_source")) - cfg.versionfile_build = section.get("versionfile_build") - cfg.tag_prefix = cast(str, section.get("tag_prefix")) - if cfg.tag_prefix in ("''", '""', None): - cfg.tag_prefix = "" - cfg.parentdir_prefix = section.get("parentdir_prefix") - if isinstance(section, configparser.SectionProxy): - # Make sure configparser translates to bool - cfg.verbose = section.getboolean("verbose") - else: - cfg.verbose = section.get("verbose") - - return cfg - - -class NotThisMethod(Exception): - """Exception raised if a method is not valid for the current scenario.""" - - -# these dictionaries contain VCS-specific tools -LONG_VERSION_PY: Dict[str, str] = {} -HANDLERS: Dict[str, Dict[str, Callable]] = {} - - -def register_vcs_handler(vcs: str, method: str) -> Callable: # decorator - """Create decorator to mark a method as the handler of a VCS.""" - def decorate(f: Callable) -> Callable: - """Store f in HANDLERS[vcs][method].""" - HANDLERS.setdefault(vcs, {})[method] = f - return f - return decorate - - -def run_command( - commands: List[str], - args: List[str], - cwd: Optional[str] = None, - verbose: bool = False, - hide_stderr: bool = False, - env: Optional[Dict[str, str]] = None, -) -> Tuple[Optional[str], Optional[int]]: - """Call the given command(s).""" - assert isinstance(commands, list) - process = None - - popen_kwargs: Dict[str, Any] = {} - if sys.platform == "win32": - # This hides the console window if pythonw.exe is used - startupinfo = subprocess.STARTUPINFO() - startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW - popen_kwargs["startupinfo"] = startupinfo - - for command in commands: - try: - dispcmd = str([command] + args) - # remember shell=False, so use git.cmd on windows, not just git - process = subprocess.Popen([command] + args, cwd=cwd, env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None), **popen_kwargs) - break - except OSError as e: - if e.errno == errno.ENOENT: - continue - if verbose: - print("unable to run %s" % dispcmd) - print(e) - return None, None - else: - if verbose: - print("unable to find command, tried %s" % (commands,)) - return None, None - stdout = process.communicate()[0].strip().decode() - if process.returncode != 0: - if verbose: - print("unable to run %s (error)" % dispcmd) - print("stdout was %s" % stdout) - return None, process.returncode - return stdout, process.returncode - - -LONG_VERSION_PY['git'] = r''' -# This file helps to compute a version number in source trees obtained from -# git-archive tarball (such as those provided by githubs download-from-tag -# feature). Distribution tarballs (built by setup.py sdist) and build -# directories (produced by setup.py build) will contain a much shorter file -# that just contains the computed version number. - -# This file is released into the public domain. -# Generated by versioneer-0.29 -# https://github.com/python-versioneer/python-versioneer - -"""Git implementation of _version.py.""" - -import errno -import os -import re -import subprocess -import sys -from typing import Any, Callable, Dict, List, Optional, Tuple -import functools - - -def get_keywords() -> Dict[str, str]: - """Get the keywords needed to look up the version information.""" - # these strings will be replaced by git during git-archive. - # setup.py/versioneer.py will grep for the variable names, so they must - # each be defined on a line of their own. _version.py will just call - # get_keywords(). - git_refnames = "%(DOLLAR)sFormat:%%d%(DOLLAR)s" - git_full = "%(DOLLAR)sFormat:%%H%(DOLLAR)s" - git_date = "%(DOLLAR)sFormat:%%ci%(DOLLAR)s" - keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} - return keywords - - -class VersioneerConfig: - """Container for Versioneer configuration parameters.""" - - VCS: str - style: str - tag_prefix: str - parentdir_prefix: str - versionfile_source: str - verbose: bool - - -def get_config() -> VersioneerConfig: - """Create, populate and return the VersioneerConfig() object.""" - # these strings are filled in when 'setup.py versioneer' creates - # _version.py - cfg = VersioneerConfig() - cfg.VCS = "git" - cfg.style = "%(STYLE)s" - cfg.tag_prefix = "%(TAG_PREFIX)s" - cfg.parentdir_prefix = "%(PARENTDIR_PREFIX)s" - cfg.versionfile_source = "%(VERSIONFILE_SOURCE)s" - cfg.verbose = False - return cfg - - -class NotThisMethod(Exception): - """Exception raised if a method is not valid for the current scenario.""" - - -LONG_VERSION_PY: Dict[str, str] = {} -HANDLERS: Dict[str, Dict[str, Callable]] = {} - - -def register_vcs_handler(vcs: str, method: str) -> Callable: # decorator - """Create decorator to mark a method as the handler of a VCS.""" - def decorate(f: Callable) -> Callable: - """Store f in HANDLERS[vcs][method].""" - if vcs not in HANDLERS: - HANDLERS[vcs] = {} - HANDLERS[vcs][method] = f - return f - return decorate - - -def run_command( - commands: List[str], - args: List[str], - cwd: Optional[str] = None, - verbose: bool = False, - hide_stderr: bool = False, - env: Optional[Dict[str, str]] = None, -) -> Tuple[Optional[str], Optional[int]]: - """Call the given command(s).""" - assert isinstance(commands, list) - process = None - - popen_kwargs: Dict[str, Any] = {} - if sys.platform == "win32": - # This hides the console window if pythonw.exe is used - startupinfo = subprocess.STARTUPINFO() - startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW - popen_kwargs["startupinfo"] = startupinfo - - for command in commands: - try: - dispcmd = str([command] + args) - # remember shell=False, so use git.cmd on windows, not just git - process = subprocess.Popen([command] + args, cwd=cwd, env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None), **popen_kwargs) - break - except OSError as e: - if e.errno == errno.ENOENT: - continue - if verbose: - print("unable to run %%s" %% dispcmd) - print(e) - return None, None - else: - if verbose: - print("unable to find command, tried %%s" %% (commands,)) - return None, None - stdout = process.communicate()[0].strip().decode() - if process.returncode != 0: - if verbose: - print("unable to run %%s (error)" %% dispcmd) - print("stdout was %%s" %% stdout) - return None, process.returncode - return stdout, process.returncode - - -def versions_from_parentdir( - parentdir_prefix: str, - root: str, - verbose: bool, -) -> Dict[str, Any]: - """Try to determine the version from the parent directory name. - - Source tarballs conventionally unpack into a directory that includes both - the project name and a version string. We will also support searching up - two directory levels for an appropriately named parent directory - """ - rootdirs = [] - - for _ in range(3): - dirname = os.path.basename(root) - if dirname.startswith(parentdir_prefix): - return {"version": dirname[len(parentdir_prefix):], - "full-revisionid": None, - "dirty": False, "error": None, "date": None} - rootdirs.append(root) - root = os.path.dirname(root) # up a level - - if verbose: - print("Tried directories %%s but none started with prefix %%s" %% - (str(rootdirs), parentdir_prefix)) - raise NotThisMethod("rootdir doesn't start with parentdir_prefix") - - -@register_vcs_handler("git", "get_keywords") -def git_get_keywords(versionfile_abs: str) -> Dict[str, str]: - """Extract version information from the given file.""" - # the code embedded in _version.py can just fetch the value of these - # keywords. When used from setup.py, we don't want to import _version.py, - # so we do it with a regexp instead. This function is not used from - # _version.py. - keywords: Dict[str, str] = {} - try: - with open(versionfile_abs, "r") as fobj: - for line in fobj: - if line.strip().startswith("git_refnames ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["refnames"] = mo.group(1) - if line.strip().startswith("git_full ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["full"] = mo.group(1) - if line.strip().startswith("git_date ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["date"] = mo.group(1) - except OSError: - pass - return keywords - - -@register_vcs_handler("git", "keywords") -def git_versions_from_keywords( - keywords: Dict[str, str], - tag_prefix: str, - verbose: bool, -) -> Dict[str, Any]: - """Get version information from git keywords.""" - if "refnames" not in keywords: - raise NotThisMethod("Short version file found") - date = keywords.get("date") - if date is not None: - # Use only the last line. Previous lines may contain GPG signature - # information. - date = date.splitlines()[-1] - - # git-2.2.0 added "%%cI", which expands to an ISO-8601 -compliant - # datestamp. However we prefer "%%ci" (which expands to an "ISO-8601 - # -like" string, which we must then edit to make compliant), because - # it's been around since git-1.5.3, and it's too difficult to - # discover which version we're using, or to work around using an - # older one. - date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - refnames = keywords["refnames"].strip() - if refnames.startswith("$Format"): - if verbose: - print("keywords are unexpanded, not using") - raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = {r.strip() for r in refnames.strip("()").split(",")} - # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of - # just "foo-1.0". If we see a "tag: " prefix, prefer those. - TAG = "tag: " - tags = {r[len(TAG):] for r in refs if r.startswith(TAG)} - if not tags: - # Either we're using git < 1.8.3, or there really are no tags. We use - # a heuristic: assume all version tags have a digit. The old git %%d - # expansion behaves like git log --decorate=short and strips out the - # refs/heads/ and refs/tags/ prefixes that would let us distinguish - # between branches and tags. By ignoring refnames without digits, we - # filter out many common branch names like "release" and - # "stabilization", as well as "HEAD" and "master". - tags = {r for r in refs if re.search(r'\d', r)} - if verbose: - print("discarding '%%s', no digits" %% ",".join(refs - tags)) - if verbose: - print("likely tags: %%s" %% ",".join(sorted(tags))) - for ref in sorted(tags): - # sorting will prefer e.g. "2.0" over "2.0rc1" - if ref.startswith(tag_prefix): - r = ref[len(tag_prefix):] - # Filter out refs that exactly match prefix or that don't start - # with a number once the prefix is stripped (mostly a concern - # when prefix is '') - if not re.match(r'\d', r): - continue - if verbose: - print("picking %%s" %% r) - return {"version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": None, - "date": date} - # no suitable tags, so version is "0+unknown", but full hex is still there - if verbose: - print("no suitable tags, using unknown + full revision id") - return {"version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": "no suitable tags", "date": None} - - -@register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs( - tag_prefix: str, - root: str, - verbose: bool, - runner: Callable = run_command -) -> Dict[str, Any]: - """Get version from 'git describe' in the root of the source tree. - - This only gets called if the git-archive 'subst' keywords were *not* - expanded, and _version.py hasn't already been rewritten with a short - version string, meaning we're inside a checked out source tree. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - - # GIT_DIR can interfere with correct operation of Versioneer. - # It may be intended to be passed to the Versioneer-versioned project, - # but that should not change where we get our version from. - env = os.environ.copy() - env.pop("GIT_DIR", None) - runner = functools.partial(runner, env=env) - - _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=not verbose) - if rc != 0: - if verbose: - print("Directory %%s not under git control" %% root) - raise NotThisMethod("'git rev-parse --git-dir' returned error") - - # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] - # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = runner(GITS, [ - "describe", "--tags", "--dirty", "--always", "--long", - "--match", f"{tag_prefix}[[:digit:]]*" - ], cwd=root) - # --long was added in git-1.5.5 - if describe_out is None: - raise NotThisMethod("'git describe' failed") - describe_out = describe_out.strip() - full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) - if full_out is None: - raise NotThisMethod("'git rev-parse' failed") - full_out = full_out.strip() - - pieces: Dict[str, Any] = {} - pieces["long"] = full_out - pieces["short"] = full_out[:7] # maybe improved later - pieces["error"] = None - - branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], - cwd=root) - # --abbrev-ref was added in git-1.6.3 - if rc != 0 or branch_name is None: - raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") - branch_name = branch_name.strip() - - if branch_name == "HEAD": - # If we aren't exactly on a branch, pick a branch which represents - # the current commit. If all else fails, we are on a branchless - # commit. - branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) - # --contains was added in git-1.5.4 - if rc != 0 or branches is None: - raise NotThisMethod("'git branch --contains' returned error") - branches = branches.split("\n") - - # Remove the first line if we're running detached - if "(" in branches[0]: - branches.pop(0) - - # Strip off the leading "* " from the list of branches. - branches = [branch[2:] for branch in branches] - if "master" in branches: - branch_name = "master" - elif not branches: - branch_name = None - else: - # Pick the first branch that is returned. Good or bad. - branch_name = branches[0] - - pieces["branch"] = branch_name - - # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] - # TAG might have hyphens. - git_describe = describe_out - - # look for -dirty suffix - dirty = git_describe.endswith("-dirty") - pieces["dirty"] = dirty - if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] - - # now we have TAG-NUM-gHEX or HEX - - if "-" in git_describe: - # TAG-NUM-gHEX - mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) - if not mo: - # unparsable. Maybe git-describe is misbehaving? - pieces["error"] = ("unable to parse git-describe output: '%%s'" - %% describe_out) - return pieces - - # tag - full_tag = mo.group(1) - if not full_tag.startswith(tag_prefix): - if verbose: - fmt = "tag '%%s' doesn't start with prefix '%%s'" - print(fmt %% (full_tag, tag_prefix)) - pieces["error"] = ("tag '%%s' doesn't start with prefix '%%s'" - %% (full_tag, tag_prefix)) - return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] - - # distance: number of commits since tag - pieces["distance"] = int(mo.group(2)) - - # commit: short hex revision ID - pieces["short"] = mo.group(3) - - else: - # HEX: no tags - pieces["closest-tag"] = None - out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root) - pieces["distance"] = len(out.split()) # total number of commits - - # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = runner(GITS, ["show", "-s", "--format=%%ci", "HEAD"], cwd=root)[0].strip() - # Use only the last line. Previous lines may contain GPG signature - # information. - date = date.splitlines()[-1] - pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - - return pieces - - -def plus_or_dot(pieces: Dict[str, Any]) -> str: - """Return a + if we don't already have one, else return a .""" - if "+" in pieces.get("closest-tag", ""): - return "." - return "+" - - -def render_pep440(pieces: Dict[str, Any]) -> str: - """Build up version string, with post-release "local version identifier". - - Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you - get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty - - Exceptions: - 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += plus_or_dot(pieces) - rendered += "%%d.g%%s" %% (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0+untagged.%%d.g%%s" %% (pieces["distance"], - pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_branch(pieces: Dict[str, Any]) -> str: - """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . - - The ".dev0" means not master branch. Note that .dev0 sorts backwards - (a feature branch will appear "older" than the master branch). - - Exceptions: - 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "%%d.g%%s" %% (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0" - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += "+untagged.%%d.g%%s" %% (pieces["distance"], - pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def pep440_split_post(ver: str) -> Tuple[str, Optional[int]]: - """Split pep440 version string at the post-release segment. - - Returns the release segments before the post-release and the - post-release version number (or -1 if no post-release segment is present). - """ - vc = str.split(ver, ".post") - return vc[0], int(vc[1] or 0) if len(vc) == 2 else None - - -def render_pep440_pre(pieces: Dict[str, Any]) -> str: - """TAG[.postN.devDISTANCE] -- No -dirty. - - Exceptions: - 1: no tags. 0.post0.devDISTANCE - """ - if pieces["closest-tag"]: - if pieces["distance"]: - # update the post release segment - tag_version, post_version = pep440_split_post(pieces["closest-tag"]) - rendered = tag_version - if post_version is not None: - rendered += ".post%%d.dev%%d" %% (post_version + 1, pieces["distance"]) - else: - rendered += ".post0.dev%%d" %% (pieces["distance"]) - else: - # no commits, use the tag as the version - rendered = pieces["closest-tag"] - else: - # exception #1 - rendered = "0.post0.dev%%d" %% pieces["distance"] - return rendered - - -def render_pep440_post(pieces: Dict[str, Any]) -> str: - """TAG[.postDISTANCE[.dev0]+gHEX] . - - The ".dev0" means dirty. Note that .dev0 sorts backwards - (a dirty tree will appear "older" than the corresponding clean one), - but you shouldn't be releasing software with -dirty anyways. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%%d" %% pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%%s" %% pieces["short"] - else: - # exception #1 - rendered = "0.post%%d" %% pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += "+g%%s" %% pieces["short"] - return rendered - - -def render_pep440_post_branch(pieces: Dict[str, Any]) -> str: - """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . - - The ".dev0" means not master branch. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%%d" %% pieces["distance"] - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%%s" %% pieces["short"] - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0.post%%d" %% pieces["distance"] - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += "+g%%s" %% pieces["short"] - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_old(pieces: Dict[str, Any]) -> str: - """TAG[.postDISTANCE[.dev0]] . - - The ".dev0" means dirty. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%%d" %% pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - else: - # exception #1 - rendered = "0.post%%d" %% pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - return rendered - - -def render_git_describe(pieces: Dict[str, Any]) -> str: - """TAG[-DISTANCE-gHEX][-dirty]. - - Like 'git describe --tags --dirty --always'. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render_git_describe_long(pieces: Dict[str, Any]) -> str: - """TAG-DISTANCE-gHEX[-dirty]. - - Like 'git describe --tags --dirty --always -long'. - The distance/hash is unconditional. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render(pieces: Dict[str, Any], style: str) -> Dict[str, Any]: - """Render the given version pieces into the requested style.""" - if pieces["error"]: - return {"version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None} - - if not style or style == "default": - style = "pep440" # the default - - if style == "pep440": - rendered = render_pep440(pieces) - elif style == "pep440-branch": - rendered = render_pep440_branch(pieces) - elif style == "pep440-pre": - rendered = render_pep440_pre(pieces) - elif style == "pep440-post": - rendered = render_pep440_post(pieces) - elif style == "pep440-post-branch": - rendered = render_pep440_post_branch(pieces) - elif style == "pep440-old": - rendered = render_pep440_old(pieces) - elif style == "git-describe": - rendered = render_git_describe(pieces) - elif style == "git-describe-long": - rendered = render_git_describe_long(pieces) - else: - raise ValueError("unknown style '%%s'" %% style) - - return {"version": rendered, "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], "error": None, - "date": pieces.get("date")} - - -def get_versions() -> Dict[str, Any]: - """Get version information or return default if unable to do so.""" - # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have - # __file__, we can work backwards from there to the root. Some - # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which - # case we can only use expanded keywords. - - cfg = get_config() - verbose = cfg.verbose - - try: - return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, - verbose) - except NotThisMethod: - pass - - try: - root = os.path.realpath(__file__) - # versionfile_source is the relative path from the top of the source - # tree (where the .git directory might live) to this file. Invert - # this to find the root from __file__. - for _ in cfg.versionfile_source.split('/'): - root = os.path.dirname(root) - except NameError: - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to find root of source tree", - "date": None} - - try: - pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) - return render(pieces, cfg.style) - except NotThisMethod: - pass - - try: - if cfg.parentdir_prefix: - return versions_from_parentdir(cfg.parentdir_prefix, root, verbose) - except NotThisMethod: - pass - - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to compute version", "date": None} -''' - - -@register_vcs_handler("git", "get_keywords") -def git_get_keywords(versionfile_abs: str) -> Dict[str, str]: - """Extract version information from the given file.""" - # the code embedded in _version.py can just fetch the value of these - # keywords. When used from setup.py, we don't want to import _version.py, - # so we do it with a regexp instead. This function is not used from - # _version.py. - keywords: Dict[str, str] = {} - try: - with open(versionfile_abs, "r") as fobj: - for line in fobj: - if line.strip().startswith("git_refnames ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["refnames"] = mo.group(1) - if line.strip().startswith("git_full ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["full"] = mo.group(1) - if line.strip().startswith("git_date ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["date"] = mo.group(1) - except OSError: - pass - return keywords - - -@register_vcs_handler("git", "keywords") -def git_versions_from_keywords( - keywords: Dict[str, str], - tag_prefix: str, - verbose: bool, -) -> Dict[str, Any]: - """Get version information from git keywords.""" - if "refnames" not in keywords: - raise NotThisMethod("Short version file found") - date = keywords.get("date") - if date is not None: - # Use only the last line. Previous lines may contain GPG signature - # information. - date = date.splitlines()[-1] - - # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant - # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 - # -like" string, which we must then edit to make compliant), because - # it's been around since git-1.5.3, and it's too difficult to - # discover which version we're using, or to work around using an - # older one. - date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - refnames = keywords["refnames"].strip() - if refnames.startswith("$Format"): - if verbose: - print("keywords are unexpanded, not using") - raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = {r.strip() for r in refnames.strip("()").split(",")} - # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of - # just "foo-1.0". If we see a "tag: " prefix, prefer those. - TAG = "tag: " - tags = {r[len(TAG):] for r in refs if r.startswith(TAG)} - if not tags: - # Either we're using git < 1.8.3, or there really are no tags. We use - # a heuristic: assume all version tags have a digit. The old git %d - # expansion behaves like git log --decorate=short and strips out the - # refs/heads/ and refs/tags/ prefixes that would let us distinguish - # between branches and tags. By ignoring refnames without digits, we - # filter out many common branch names like "release" and - # "stabilization", as well as "HEAD" and "master". - tags = {r for r in refs if re.search(r'\d', r)} - if verbose: - print("discarding '%s', no digits" % ",".join(refs - tags)) - if verbose: - print("likely tags: %s" % ",".join(sorted(tags))) - for ref in sorted(tags): - # sorting will prefer e.g. "2.0" over "2.0rc1" - if ref.startswith(tag_prefix): - r = ref[len(tag_prefix):] - # Filter out refs that exactly match prefix or that don't start - # with a number once the prefix is stripped (mostly a concern - # when prefix is '') - if not re.match(r'\d', r): - continue - if verbose: - print("picking %s" % r) - return {"version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": None, - "date": date} - # no suitable tags, so version is "0+unknown", but full hex is still there - if verbose: - print("no suitable tags, using unknown + full revision id") - return {"version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": "no suitable tags", "date": None} - - -@register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs( - tag_prefix: str, - root: str, - verbose: bool, - runner: Callable = run_command -) -> Dict[str, Any]: - """Get version from 'git describe' in the root of the source tree. - - This only gets called if the git-archive 'subst' keywords were *not* - expanded, and _version.py hasn't already been rewritten with a short - version string, meaning we're inside a checked out source tree. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - - # GIT_DIR can interfere with correct operation of Versioneer. - # It may be intended to be passed to the Versioneer-versioned project, - # but that should not change where we get our version from. - env = os.environ.copy() - env.pop("GIT_DIR", None) - runner = functools.partial(runner, env=env) - - _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=not verbose) - if rc != 0: - if verbose: - print("Directory %s not under git control" % root) - raise NotThisMethod("'git rev-parse --git-dir' returned error") - - # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] - # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = runner(GITS, [ - "describe", "--tags", "--dirty", "--always", "--long", - "--match", f"{tag_prefix}[[:digit:]]*" - ], cwd=root) - # --long was added in git-1.5.5 - if describe_out is None: - raise NotThisMethod("'git describe' failed") - describe_out = describe_out.strip() - full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) - if full_out is None: - raise NotThisMethod("'git rev-parse' failed") - full_out = full_out.strip() - - pieces: Dict[str, Any] = {} - pieces["long"] = full_out - pieces["short"] = full_out[:7] # maybe improved later - pieces["error"] = None - - branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], - cwd=root) - # --abbrev-ref was added in git-1.6.3 - if rc != 0 or branch_name is None: - raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") - branch_name = branch_name.strip() - - if branch_name == "HEAD": - # If we aren't exactly on a branch, pick a branch which represents - # the current commit. If all else fails, we are on a branchless - # commit. - branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) - # --contains was added in git-1.5.4 - if rc != 0 or branches is None: - raise NotThisMethod("'git branch --contains' returned error") - branches = branches.split("\n") - - # Remove the first line if we're running detached - if "(" in branches[0]: - branches.pop(0) - - # Strip off the leading "* " from the list of branches. - branches = [branch[2:] for branch in branches] - if "master" in branches: - branch_name = "master" - elif not branches: - branch_name = None - else: - # Pick the first branch that is returned. Good or bad. - branch_name = branches[0] - - pieces["branch"] = branch_name - - # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] - # TAG might have hyphens. - git_describe = describe_out - - # look for -dirty suffix - dirty = git_describe.endswith("-dirty") - pieces["dirty"] = dirty - if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] - - # now we have TAG-NUM-gHEX or HEX - - if "-" in git_describe: - # TAG-NUM-gHEX - mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) - if not mo: - # unparsable. Maybe git-describe is misbehaving? - pieces["error"] = ("unable to parse git-describe output: '%s'" - % describe_out) - return pieces - - # tag - full_tag = mo.group(1) - if not full_tag.startswith(tag_prefix): - if verbose: - fmt = "tag '%s' doesn't start with prefix '%s'" - print(fmt % (full_tag, tag_prefix)) - pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" - % (full_tag, tag_prefix)) - return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] - - # distance: number of commits since tag - pieces["distance"] = int(mo.group(2)) - - # commit: short hex revision ID - pieces["short"] = mo.group(3) - - else: - # HEX: no tags - pieces["closest-tag"] = None - out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root) - pieces["distance"] = len(out.split()) # total number of commits - - # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip() - # Use only the last line. Previous lines may contain GPG signature - # information. - date = date.splitlines()[-1] - pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - - return pieces - - -def do_vcs_install(versionfile_source: str, ipy: Optional[str]) -> None: - """Git-specific installation logic for Versioneer. - - For Git, this means creating/changing .gitattributes to mark _version.py - for export-subst keyword substitution. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - files = [versionfile_source] - if ipy: - files.append(ipy) - if "VERSIONEER_PEP518" not in globals(): - try: - my_path = __file__ - if my_path.endswith((".pyc", ".pyo")): - my_path = os.path.splitext(my_path)[0] + ".py" - versioneer_file = os.path.relpath(my_path) - except NameError: - versioneer_file = "versioneer.py" - files.append(versioneer_file) - present = False - try: - with open(".gitattributes", "r") as fobj: - for line in fobj: - if line.strip().startswith(versionfile_source): - if "export-subst" in line.strip().split()[1:]: - present = True - break - except OSError: - pass - if not present: - with open(".gitattributes", "a+") as fobj: - fobj.write(f"{versionfile_source} export-subst\n") - files.append(".gitattributes") - run_command(GITS, ["add", "--"] + files) - - -def versions_from_parentdir( - parentdir_prefix: str, - root: str, - verbose: bool, -) -> Dict[str, Any]: - """Try to determine the version from the parent directory name. - - Source tarballs conventionally unpack into a directory that includes both - the project name and a version string. We will also support searching up - two directory levels for an appropriately named parent directory - """ - rootdirs = [] - - for _ in range(3): - dirname = os.path.basename(root) - if dirname.startswith(parentdir_prefix): - return {"version": dirname[len(parentdir_prefix):], - "full-revisionid": None, - "dirty": False, "error": None, "date": None} - rootdirs.append(root) - root = os.path.dirname(root) # up a level - - if verbose: - print("Tried directories %s but none started with prefix %s" % - (str(rootdirs), parentdir_prefix)) - raise NotThisMethod("rootdir doesn't start with parentdir_prefix") - - -SHORT_VERSION_PY = """ -# This file was generated by 'versioneer.py' (0.29) from -# revision-control system data, or from the parent directory name of an -# unpacked source archive. Distribution tarballs contain a pre-generated copy -# of this file. - -import json - -version_json = ''' -%s -''' # END VERSION_JSON - - -def get_versions(): - return json.loads(version_json) -""" - - -def versions_from_file(filename: str) -> Dict[str, Any]: - """Try to determine the version from _version.py if present.""" - try: - with open(filename) as f: - contents = f.read() - except OSError: - raise NotThisMethod("unable to read _version.py") - mo = re.search(r"version_json = '''\n(.*)''' # END VERSION_JSON", - contents, re.M | re.S) - if not mo: - mo = re.search(r"version_json = '''\r\n(.*)''' # END VERSION_JSON", - contents, re.M | re.S) - if not mo: - raise NotThisMethod("no version_json in _version.py") - return json.loads(mo.group(1)) - - -def write_to_version_file(filename: str, versions: Dict[str, Any]) -> None: - """Write the given version number to the given _version.py file.""" - contents = json.dumps(versions, sort_keys=True, - indent=1, separators=(",", ": ")) - with open(filename, "w") as f: - f.write(SHORT_VERSION_PY % contents) - - print("set %s to '%s'" % (filename, versions["version"])) - - -def plus_or_dot(pieces: Dict[str, Any]) -> str: - """Return a + if we don't already have one, else return a .""" - if "+" in pieces.get("closest-tag", ""): - return "." - return "+" - - -def render_pep440(pieces: Dict[str, Any]) -> str: - """Build up version string, with post-release "local version identifier". - - Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you - get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty - - Exceptions: - 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += plus_or_dot(pieces) - rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0+untagged.%d.g%s" % (pieces["distance"], - pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_branch(pieces: Dict[str, Any]) -> str: - """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . - - The ".dev0" means not master branch. Note that .dev0 sorts backwards - (a feature branch will appear "older" than the master branch). - - Exceptions: - 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0" - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += "+untagged.%d.g%s" % (pieces["distance"], - pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def pep440_split_post(ver: str) -> Tuple[str, Optional[int]]: - """Split pep440 version string at the post-release segment. - - Returns the release segments before the post-release and the - post-release version number (or -1 if no post-release segment is present). - """ - vc = str.split(ver, ".post") - return vc[0], int(vc[1] or 0) if len(vc) == 2 else None - - -def render_pep440_pre(pieces: Dict[str, Any]) -> str: - """TAG[.postN.devDISTANCE] -- No -dirty. - - Exceptions: - 1: no tags. 0.post0.devDISTANCE - """ - if pieces["closest-tag"]: - if pieces["distance"]: - # update the post release segment - tag_version, post_version = pep440_split_post(pieces["closest-tag"]) - rendered = tag_version - if post_version is not None: - rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"]) - else: - rendered += ".post0.dev%d" % (pieces["distance"]) - else: - # no commits, use the tag as the version - rendered = pieces["closest-tag"] - else: - # exception #1 - rendered = "0.post0.dev%d" % pieces["distance"] - return rendered - - -def render_pep440_post(pieces: Dict[str, Any]) -> str: - """TAG[.postDISTANCE[.dev0]+gHEX] . - - The ".dev0" means dirty. Note that .dev0 sorts backwards - (a dirty tree will appear "older" than the corresponding clean one), - but you shouldn't be releasing software with -dirty anyways. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%s" % pieces["short"] - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += "+g%s" % pieces["short"] - return rendered - - -def render_pep440_post_branch(pieces: Dict[str, Any]) -> str: - """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . - - The ".dev0" means not master branch. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%s" % pieces["short"] - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["branch"] != "master": - rendered += ".dev0" - rendered += "+g%s" % pieces["short"] - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_old(pieces: Dict[str, Any]) -> str: - """TAG[.postDISTANCE[.dev0]] . - - The ".dev0" means dirty. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - return rendered - - -def render_git_describe(pieces: Dict[str, Any]) -> str: - """TAG[-DISTANCE-gHEX][-dirty]. - - Like 'git describe --tags --dirty --always'. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render_git_describe_long(pieces: Dict[str, Any]) -> str: - """TAG-DISTANCE-gHEX[-dirty]. - - Like 'git describe --tags --dirty --always -long'. - The distance/hash is unconditional. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render(pieces: Dict[str, Any], style: str) -> Dict[str, Any]: - """Render the given version pieces into the requested style.""" - if pieces["error"]: - return {"version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None} - - if not style or style == "default": - style = "pep440" # the default - - if style == "pep440": - rendered = render_pep440(pieces) - elif style == "pep440-branch": - rendered = render_pep440_branch(pieces) - elif style == "pep440-pre": - rendered = render_pep440_pre(pieces) - elif style == "pep440-post": - rendered = render_pep440_post(pieces) - elif style == "pep440-post-branch": - rendered = render_pep440_post_branch(pieces) - elif style == "pep440-old": - rendered = render_pep440_old(pieces) - elif style == "git-describe": - rendered = render_git_describe(pieces) - elif style == "git-describe-long": - rendered = render_git_describe_long(pieces) - else: - raise ValueError("unknown style '%s'" % style) - - return {"version": rendered, "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], "error": None, - "date": pieces.get("date")} - - -class VersioneerBadRootError(Exception): - """The project root directory is unknown or missing key files.""" - - -def get_versions(verbose: bool = False) -> Dict[str, Any]: - """Get the project version from whatever source is available. - - Returns dict with two keys: 'version' and 'full'. - """ - if "versioneer" in sys.modules: - # see the discussion in cmdclass.py:get_cmdclass() - del sys.modules["versioneer"] - - root = get_root() - cfg = get_config_from_root(root) - - assert cfg.VCS is not None, "please set [versioneer]VCS= in setup.cfg" - handlers = HANDLERS.get(cfg.VCS) - assert handlers, "unrecognized VCS '%s'" % cfg.VCS - verbose = verbose or bool(cfg.verbose) # `bool()` used to avoid `None` - assert cfg.versionfile_source is not None, \ - "please set versioneer.versionfile_source" - assert cfg.tag_prefix is not None, "please set versioneer.tag_prefix" - - versionfile_abs = os.path.join(root, cfg.versionfile_source) - - # extract version from first of: _version.py, VCS command (e.g. 'git - # describe'), parentdir. This is meant to work for developers using a - # source checkout, for users of a tarball created by 'setup.py sdist', - # and for users of a tarball/zipball created by 'git archive' or github's - # download-from-tag feature or the equivalent in other VCSes. - - get_keywords_f = handlers.get("get_keywords") - from_keywords_f = handlers.get("keywords") - if get_keywords_f and from_keywords_f: - try: - keywords = get_keywords_f(versionfile_abs) - ver = from_keywords_f(keywords, cfg.tag_prefix, verbose) - if verbose: - print("got version from expanded keyword %s" % ver) - return ver - except NotThisMethod: - pass - - try: - ver = versions_from_file(versionfile_abs) - if verbose: - print("got version from file %s %s" % (versionfile_abs, ver)) - return ver - except NotThisMethod: - pass - - from_vcs_f = handlers.get("pieces_from_vcs") - if from_vcs_f: - try: - pieces = from_vcs_f(cfg.tag_prefix, root, verbose) - ver = render(pieces, cfg.style) - if verbose: - print("got version from VCS %s" % ver) - return ver - except NotThisMethod: - pass - - try: - if cfg.parentdir_prefix: - ver = versions_from_parentdir(cfg.parentdir_prefix, root, verbose) - if verbose: - print("got version from parentdir %s" % ver) - return ver - except NotThisMethod: - pass - - if verbose: - print("unable to compute version") - - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, "error": "unable to compute version", - "date": None} - - -def get_version() -> str: - """Get the short version string for this project.""" - return get_versions()["version"] - - -def get_cmdclass(cmdclass: Optional[Dict[str, Any]] = None): - """Get the custom setuptools subclasses used by Versioneer. - - If the package uses a different cmdclass (e.g. one from numpy), it - should be provide as an argument. - """ - if "versioneer" in sys.modules: - del sys.modules["versioneer"] - # this fixes the "python setup.py develop" case (also 'install' and - # 'easy_install .'), in which subdependencies of the main project are - # built (using setup.py bdist_egg) in the same python process. Assume - # a main project A and a dependency B, which use different versions - # of Versioneer. A's setup.py imports A's Versioneer, leaving it in - # sys.modules by the time B's setup.py is executed, causing B to run - # with the wrong versioneer. Setuptools wraps the sub-dep builds in a - # sandbox that restores sys.modules to it's pre-build state, so the - # parent is protected against the child's "import versioneer". By - # removing ourselves from sys.modules here, before the child build - # happens, we protect the child from the parent's versioneer too. - # Also see https://github.com/python-versioneer/python-versioneer/issues/52 - - cmds = {} if cmdclass is None else cmdclass.copy() - - # we add "version" to setuptools - from setuptools import Command - - class cmd_version(Command): - description = "report generated version string" - user_options: List[Tuple[str, str, str]] = [] - boolean_options: List[str] = [] - - def initialize_options(self) -> None: - pass - - def finalize_options(self) -> None: - pass - - def run(self) -> None: - vers = get_versions(verbose=True) - print("Version: %s" % vers["version"]) - print(" full-revisionid: %s" % vers.get("full-revisionid")) - print(" dirty: %s" % vers.get("dirty")) - print(" date: %s" % vers.get("date")) - if vers["error"]: - print(" error: %s" % vers["error"]) - cmds["version"] = cmd_version - - # we override "build_py" in setuptools - # - # most invocation pathways end up running build_py: - # distutils/build -> build_py - # distutils/install -> distutils/build ->.. - # setuptools/bdist_wheel -> distutils/install ->.. - # setuptools/bdist_egg -> distutils/install_lib -> build_py - # setuptools/install -> bdist_egg ->.. - # setuptools/develop -> ? - # pip install: - # copies source tree to a tempdir before running egg_info/etc - # if .git isn't copied too, 'git describe' will fail - # then does setup.py bdist_wheel, or sometimes setup.py install - # setup.py egg_info -> ? - - # pip install -e . and setuptool/editable_wheel will invoke build_py - # but the build_py command is not expected to copy any files. - - # we override different "build_py" commands for both environments - if 'build_py' in cmds: - _build_py: Any = cmds['build_py'] - else: - from setuptools.command.build_py import build_py as _build_py - - class cmd_build_py(_build_py): - def run(self) -> None: - root = get_root() - cfg = get_config_from_root(root) - versions = get_versions() - _build_py.run(self) - if getattr(self, "editable_mode", False): - # During editable installs `.py` and data files are - # not copied to build_lib - return - # now locate _version.py in the new build/ directory and replace - # it with an updated value - if cfg.versionfile_build: - target_versionfile = os.path.join(self.build_lib, - cfg.versionfile_build) - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, versions) - cmds["build_py"] = cmd_build_py - - if 'build_ext' in cmds: - _build_ext: Any = cmds['build_ext'] - else: - from setuptools.command.build_ext import build_ext as _build_ext - - class cmd_build_ext(_build_ext): - def run(self) -> None: - root = get_root() - cfg = get_config_from_root(root) - versions = get_versions() - _build_ext.run(self) - if self.inplace: - # build_ext --inplace will only build extensions in - # build/lib<..> dir with no _version.py to write to. - # As in place builds will already have a _version.py - # in the module dir, we do not need to write one. - return - # now locate _version.py in the new build/ directory and replace - # it with an updated value - if not cfg.versionfile_build: - return - target_versionfile = os.path.join(self.build_lib, - cfg.versionfile_build) - if not os.path.exists(target_versionfile): - print(f"Warning: {target_versionfile} does not exist, skipping " - "version update. This can happen if you are running build_ext " - "without first running build_py.") - return - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, versions) - cmds["build_ext"] = cmd_build_ext - - if "cx_Freeze" in sys.modules: # cx_freeze enabled? - from cx_Freeze.dist import build_exe as _build_exe # type: ignore - # nczeczulin reports that py2exe won't like the pep440-style string - # as FILEVERSION, but it can be used for PRODUCTVERSION, e.g. - # setup(console=[{ - # "version": versioneer.get_version().split("+", 1)[0], # FILEVERSION - # "product_version": versioneer.get_version(), - # ... - - class cmd_build_exe(_build_exe): - def run(self) -> None: - root = get_root() - cfg = get_config_from_root(root) - versions = get_versions() - target_versionfile = cfg.versionfile_source - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, versions) - - _build_exe.run(self) - os.unlink(target_versionfile) - with open(cfg.versionfile_source, "w") as f: - LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % - {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) - cmds["build_exe"] = cmd_build_exe - del cmds["build_py"] - - if 'py2exe' in sys.modules: # py2exe enabled? - try: - from py2exe.setuptools_buildexe import py2exe as _py2exe # type: ignore - except ImportError: - from py2exe.distutils_buildexe import py2exe as _py2exe # type: ignore - - class cmd_py2exe(_py2exe): - def run(self) -> None: - root = get_root() - cfg = get_config_from_root(root) - versions = get_versions() - target_versionfile = cfg.versionfile_source - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, versions) - - _py2exe.run(self) - os.unlink(target_versionfile) - with open(cfg.versionfile_source, "w") as f: - LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % - {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) - cmds["py2exe"] = cmd_py2exe - - # sdist farms its file list building out to egg_info - if 'egg_info' in cmds: - _egg_info: Any = cmds['egg_info'] - else: - from setuptools.command.egg_info import egg_info as _egg_info - - class cmd_egg_info(_egg_info): - def find_sources(self) -> None: - # egg_info.find_sources builds the manifest list and writes it - # in one shot - super().find_sources() - - # Modify the filelist and normalize it - root = get_root() - cfg = get_config_from_root(root) - self.filelist.append('versioneer.py') - if cfg.versionfile_source: - # There are rare cases where versionfile_source might not be - # included by default, so we must be explicit - self.filelist.append(cfg.versionfile_source) - self.filelist.sort() - self.filelist.remove_duplicates() - - # The write method is hidden in the manifest_maker instance that - # generated the filelist and was thrown away - # We will instead replicate their final normalization (to unicode, - # and POSIX-style paths) - from setuptools import unicode_utils - normalized = [unicode_utils.filesys_decode(f).replace(os.sep, '/') - for f in self.filelist.files] - - manifest_filename = os.path.join(self.egg_info, 'SOURCES.txt') - with open(manifest_filename, 'w') as fobj: - fobj.write('\n'.join(normalized)) - - cmds['egg_info'] = cmd_egg_info - - # we override different "sdist" commands for both environments - if 'sdist' in cmds: - _sdist: Any = cmds['sdist'] - else: - from setuptools.command.sdist import sdist as _sdist - - class cmd_sdist(_sdist): - def run(self) -> None: - versions = get_versions() - self._versioneer_generated_versions = versions - # unless we update this, the command will keep using the old - # version - self.distribution.metadata.version = versions["version"] - return _sdist.run(self) - - def make_release_tree(self, base_dir: str, files: List[str]) -> None: - root = get_root() - cfg = get_config_from_root(root) - _sdist.make_release_tree(self, base_dir, files) - # now locate _version.py in the new base_dir directory - # (remembering that it may be a hardlink) and replace it with an - # updated value - target_versionfile = os.path.join(base_dir, cfg.versionfile_source) - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, - self._versioneer_generated_versions) - cmds["sdist"] = cmd_sdist - - return cmds - - -CONFIG_ERROR = """ -setup.cfg is missing the necessary Versioneer configuration. You need -a section like: - - [versioneer] - VCS = git - style = pep440 - versionfile_source = src/myproject/_version.py - versionfile_build = myproject/_version.py - tag_prefix = - parentdir_prefix = myproject- - -You will also need to edit your setup.py to use the results: - - import versioneer - setup(version=versioneer.get_version(), - cmdclass=versioneer.get_cmdclass(), ...) - -Please read the docstring in ./versioneer.py for configuration instructions, -edit setup.cfg, and re-run the installer or 'python versioneer.py setup'. -""" - -SAMPLE_CONFIG = """ -# See the docstring in versioneer.py for instructions. Note that you must -# re-run 'versioneer.py setup' after changing this section, and commit the -# resulting files. - -[versioneer] -#VCS = git -#style = pep440 -#versionfile_source = -#versionfile_build = -#tag_prefix = -#parentdir_prefix = - -""" - -OLD_SNIPPET = """ -from ._version import get_versions -__version__ = get_versions()['version'] -del get_versions -""" - -INIT_PY_SNIPPET = """ -from . import {0} -__version__ = {0}.get_versions()['version'] -""" - - -def do_setup() -> int: - """Do main VCS-independent setup function for installing Versioneer.""" - root = get_root() - try: - cfg = get_config_from_root(root) - except (OSError, configparser.NoSectionError, - configparser.NoOptionError) as e: - if isinstance(e, (OSError, configparser.NoSectionError)): - print("Adding sample versioneer config to setup.cfg", - file=sys.stderr) - with open(os.path.join(root, "setup.cfg"), "a") as f: - f.write(SAMPLE_CONFIG) - print(CONFIG_ERROR, file=sys.stderr) - return 1 - - print(" creating %s" % cfg.versionfile_source) - with open(cfg.versionfile_source, "w") as f: - LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) - - ipy = os.path.join(os.path.dirname(cfg.versionfile_source), - "__init__.py") - maybe_ipy: Optional[str] = ipy - if os.path.exists(ipy): - try: - with open(ipy, "r") as f: - old = f.read() - except OSError: - old = "" - module = os.path.splitext(os.path.basename(cfg.versionfile_source))[0] - snippet = INIT_PY_SNIPPET.format(module) - if OLD_SNIPPET in old: - print(" replacing boilerplate in %s" % ipy) - with open(ipy, "w") as f: - f.write(old.replace(OLD_SNIPPET, snippet)) - elif snippet not in old: - print(" appending to %s" % ipy) - with open(ipy, "a") as f: - f.write(snippet) - else: - print(" %s unmodified" % ipy) - else: - print(" %s doesn't exist, ok" % ipy) - maybe_ipy = None - - # Make VCS-specific changes. For git, this means creating/changing - # .gitattributes to mark _version.py for export-subst keyword - # substitution. - do_vcs_install(cfg.versionfile_source, maybe_ipy) - return 0 - - -def scan_setup_py() -> int: - """Validate the contents of setup.py against Versioneer's expectations.""" - found = set() - setters = False - errors = 0 - with open("setup.py", "r") as f: - for line in f.readlines(): - if "import versioneer" in line: - found.add("import") - if "versioneer.get_cmdclass()" in line: - found.add("cmdclass") - if "versioneer.get_version()" in line: - found.add("get_version") - if "versioneer.VCS" in line: - setters = True - if "versioneer.versionfile_source" in line: - setters = True - if len(found) != 3: - print("") - print("Your setup.py appears to be missing some important items") - print("(but I might be wrong). Please make sure it has something") - print("roughly like the following:") - print("") - print(" import versioneer") - print(" setup( version=versioneer.get_version(),") - print(" cmdclass=versioneer.get_cmdclass(), ...)") - print("") - errors += 1 - if setters: - print("You should remove lines like 'versioneer.VCS = ' and") - print("'versioneer.versionfile_source = ' . This configuration") - print("now lives in setup.cfg, and should be removed from setup.py") - print("") - errors += 1 - return errors - - -def setup_command() -> NoReturn: - """Set up Versioneer and exit with appropriate error code.""" - errors = do_setup() - errors += scan_setup_py() - sys.exit(1 if errors else 0) - - -if __name__ == "__main__": - cmd = sys.argv[1] - if cmd == "setup": - setup_command()