numerous type fixes and initial guess no dev handling

Author: RonnyPfannschmidt

.pre-commit-config.yaml

@@ -36,3 +36,4 @@ repos:
         additional_dependencies:
             - types-setuptools
             - tokenize-rt==3.2.0
+            - pytest == 6.2.5

mypy.ini

@@ -7,3 +7,4 @@ mypy_path = $MYPY_CONFIG_FILE_DIR/src
 [mypy-setuptools_scm.*]
 # disabled as it will take a bit
 # disallow_untyped_defs = True
+# strict = true

setup.cfg

@@ -62,6 +62,7 @@ setuptools_scm.parse_scm_fallback =
     PKG-INFO = setuptools_scm.hacks:parse_pkginfo
     pip-egg-info = setuptools_scm.hacks:parse_pip_egg_info
     setup.py = setuptools_scm.hacks:fallback_version
+    pyproject.toml = setuptools_scm.hacks:fallback_version
 setuptools_scm.version_scheme =
     guess-next-dev = setuptools_scm.version:guess_next_dev_version
     post-release = setuptools_scm.version:postrelease_version

src/setuptools_scm/__init__.py

@@ -4,7 +4,10 @@
 """
 import os
 import warnings
+from typing import NoReturn
+from typing import Optional
 
+from . import _types
 from ._entrypoints import _call_entrypoint_fn
 from ._entrypoints import _version_from_entrypoints
 from ._overrides import _read_pretended_version_for
@@ -22,6 +25,7 @@
 from .utils import trace
 from .version import format_version
 from .version import meta
+from .version import ScmVersion
 
 TEMPLATES = {
     ".py": """\
@@ -42,14 +46,16 @@ def version_from_scm(root):
         stacklevel=2,
     )
     config = Configuration(root=root)
-    # TODO: Is it API?
     return _version_from_entrypoints(config)
 
 
-def dump_version(root, version: str, write_to, template: "str | None" = None):
+def dump_version(
+    root: _types.PathT,
+    version: str,
+    write_to: _types.PathT,
+    template: "str | None" = None,
+):
     assert isinstance(version, str)
-    if not write_to:
-        return
     target = os.path.normpath(os.path.join(root, write_to))
     ext = os.path.splitext(target)[1]
     template = template or TEMPLATES.get(ext)
@@ -66,7 +72,7 @@ def dump_version(root, version: str, write_to, template: "str | None" = None):
         fp.write(template.format(version=version, version_tuple=version_tuple))
 
 
-def _do_parse(config):
+def _do_parse(config: Configuration) -> "ScmVersion|None":
     pretended = _read_pretended_version_for(config)
     if pretended is not None:
         return pretended
@@ -77,74 +83,68 @@ def _do_parse(config):
             raise TypeError(
                 "version parse result was a string\nplease return a parsed version"
             )
-        version = parse_result or _version_from_entrypoints(config, fallback=True)
+        version: Optional[ScmVersion]
+        if parse_result:
+            assert isinstance(parse_result, ScmVersion)
+            version = parse_result
+        else:
+            version = _version_from_entrypoints(config, fallback=True)
     else:
         # include fallbacks after dropping them from the main entrypoint
         version = _version_from_entrypoints(config) or _version_from_entrypoints(
             config, fallback=True
         )
 
-    if version:
-        return version
+    return version
+
 
+def _version_missing(config) -> NoReturn:
     raise LookupError(
-        "setuptools-scm was unable to detect version for %r.\n\n"
+        f"setuptools-scm was unable to detect version for {config.absolute_root}.\n\n"
         "Make sure you're either building from a fully intact git repository "
         "or PyPI tarballs. Most other sources (such as GitHub's tarballs, a "
         "git checkout without the .git folder) don't contain the necessary "
         "metadata and will not work.\n\n"
         "For example, if you're using pip, instead of "
         "https://github.com/user/proj/archive/master.zip "
-        "use git+https://github.com/user/proj.git#egg=proj" % config.absolute_root
+        "use git+https://github.com/user/proj.git#egg=proj"
     )
 
 
-def get_version(
-    root=".",
-    version_scheme=DEFAULT_VERSION_SCHEME,
-    local_scheme=DEFAULT_LOCAL_SCHEME,
-    write_to=None,
-    write_to_template=None,
-    relative_to=None,
-    tag_regex=DEFAULT_TAG_REGEX,
-    parentdir_prefix_version=None,
-    fallback_version=None,
-    fallback_root=".",
-    parse=None,
-    git_describe_command=None,
-    dist_name=None,
-    version_cls=None,
-    normalize=True,
-    search_parent_directories=False,
-):
+@_types.transfer_input_args(Configuration)
+def get_version(**kw) -> str:
     """
     If supplied, relative_to should be a file from which root may
     be resolved. Typically called by a script or module that is not
     in the root of the repository to direct setuptools_scm to the
     root of the repository by supplying ``__file__``.
     """
 
-    config = Configuration(**locals())
-    return _get_version(config)
+    config = Configuration(**kw)
+    maybe_version = _get_version(config)
+    if maybe_version is None:
+        _version_missing(config)
+    return maybe_version
 
 
-def _get_version(config):
+def _get_version(config: Configuration) -> "str|None":
     parsed_version = _do_parse(config)
-
-    if parsed_version:
-        version_string = format_version(
-            parsed_version,
-            version_scheme=config.version_scheme,
-            local_scheme=config.local_scheme,
-        )
+    if parsed_version is None:
+        return None
+    version_string = format_version(
+        parsed_version,
+        version_scheme=config.version_scheme,
+        local_scheme=config.local_scheme,
+    )
+    if config.write_to is not None:
         dump_version(
             root=config.root,
             version=version_string,
             write_to=config.write_to,
             template=config.write_to_template,
         )
 
-        return version_string
+    return version_string
 
 
 # Public API

src/setuptools_scm/__main__.py

@@ -27,6 +27,7 @@ def main() -> None:
         config = Configuration(root=root)
 
     version = _get_version(config)
+    assert version is not None
     if opts.strip_dev:
         version = version.partition(".dev")[0]
     print(version)

src/setuptools_scm/_entrypoints.py

@@ -5,6 +5,7 @@
 from .discover import iter_matching_entrypoints
 from .utils import function_has_arg
 from .utils import trace
+from setuptools_scm.version import ScmVersion
 
 
 def _call_entrypoint_fn(root, config, fn):
@@ -21,19 +22,23 @@ def _call_entrypoint_fn(root, config, fn):
         return fn(root)
 
 
-def _version_from_entrypoints(config: Configuration, fallback=False):
+def _version_from_entrypoints(
+    config: Configuration, fallback: bool = False
+) -> "ScmVersion|None":
     if fallback:
         entrypoint = "setuptools_scm.parse_scm_fallback"
         root = config.fallback_root
     else:
         entrypoint = "setuptools_scm.parse_scm"
         root = config.absolute_root
 
+    trace("version_from_ep", entrypoint, root)
     for ep in iter_matching_entrypoints(root, entrypoint, config):
-        version = _call_entrypoint_fn(root, config, ep.load())
+        version: Optional[ScmVersion] = _call_entrypoint_fn(root, config, ep.load())
         trace(ep, version)
         if version:
             return version
+    return None
 
 
 try:

src/setuptools_scm/_types.py

@@ -0,0 +1,31 @@
+import os
+from typing import Callable
+from typing import TYPE_CHECKING
+from typing import TypeVar
+from typing import Union
+
+if TYPE_CHECKING:
+
+    from typing_extensions import ParamSpec
+else:
+
+    class ParamSpec(list):
+        def __init__(self, _) -> None:
+            pass
+
+
+PathT = Union["os.PathLike[str]", str]
+
+
+T = TypeVar("T")
+T2 = TypeVar("T2")
+PARAMS = ParamSpec("PARAMS")
+
+
+def transfer_input_args(
+    template: "Callable[PARAMS, T]",
+) -> Callable[[Callable[..., T2]], "Callable[PARAMS, T2]"]:
+    def decorate(func: Callable[..., T2]) -> "Callable[PARAMS, T2]":
+        return func
+
+    return decorate

src/setuptools_scm/_version_cls.py

@@ -8,14 +8,14 @@
         Version, "release"
     ), "broken installation ensure packaging>=20 is available"
 except ImportError:
-    from pkg_resources._vendor.packaging.version import (
+    from pkg_resources._vendor.packaging.version import (  # type: ignore
         Version as SetuptoolsVersion,
         InvalidVersion,
     )
 
     try:
         SetuptoolsVersion.release
-        Version = SetuptoolsVersion
+        Version = SetuptoolsVersion  # type: ignore
     except AttributeError:
 
         class Version(SetuptoolsVersion):  # type: ignore

src/setuptools_scm/config.py

@@ -2,7 +2,10 @@
 import os
 import re
 import warnings
+from typing import Type
+from typing import TypeVar
 
+from . import _types as _t
 from ._version_cls import NonNormalizedVersion
 from ._version_cls import Version
 from .utils import trace
@@ -27,10 +30,13 @@ def _check_tag_regex(value):
     return regex
 
 
-def _check_absolute_root(root, relative_to):
-    trace("l", repr(locals()))
+def _check_absolute_root(root: _t.PathT, relative_to: _t.PathT):
+    trace("abs root", repr(locals()))
     if relative_to:
-        if os.path.isabs(root) and not root.startswith(relative_to):
+        if (
+            os.path.isabs(root)
+            and not os.path.commonpath([root, relative_to]) == relative_to
+        ):
             warnings.warn(
                 "absolute root path '%s' overrides relative_to '%s'"
                 % (root, relative_to)
@@ -49,33 +55,40 @@ def _check_absolute_root(root, relative_to):
     return os.path.abspath(root)
 
 
-def _lazy_tomli_load(data):
+def _lazy_tomli_load(data: str):
     from tomli import loads
 
     return loads(data)
 
 
+VersionT = TypeVar("VersionT", Version, NonNormalizedVersion)
+
+
 class Configuration:
     """Global configuration model"""
 
+    _root: _t.PathT
+    _relative_to: "_t.PathT | None"
+    version_cls: "Type[Version]|Type[NonNormalizedVersion]"
+
     def __init__(
         self,
-        relative_to=None,
-        root=".",
-        version_scheme=DEFAULT_VERSION_SCHEME,
+        relative_to: "_t.PathT | None" = None,
+        root: _t.PathT = ".",
+        version_scheme: str = DEFAULT_VERSION_SCHEME,
         local_scheme=DEFAULT_LOCAL_SCHEME,
-        write_to=None,
-        write_to_template=None,
+        write_to: "_t.PathT | None" = None,
+        write_to_template: "str|None" = None,
         tag_regex=DEFAULT_TAG_REGEX,
         parentdir_prefix_version=None,
-        fallback_version=None,
-        fallback_root=".",
+        fallback_version: "str|None" = None,
+        fallback_root: _t.PathT = ".",
         parse=None,
         git_describe_command=None,
-        dist_name=None,
-        version_cls=None,
-        normalize=True,
-        search_parent_directories=False,
+        dist_name: str = None,
+        version_cls: "Type[Version]|Type[NonNormalizedVersion]|str|None" = None,
+        normalize: bool = True,
+        search_parent_directories: bool = False,
     ):
         # TODO:
         self._relative_to = relative_to
@@ -107,18 +120,19 @@ def __init__(
         else:
             # Use `version_cls` if provided, default to packaging or pkg_resources
             if version_cls is None:
-                version_cls = Version
+                self.version_cls = Version
             elif isinstance(version_cls, str):
                 try:
                     # Not sure this will work in old python
                     import importlib
 
                     pkg, cls_name = version_cls.rsplit(".", 1)
                     version_cls_host = importlib.import_module(pkg)
-                    version_cls = getattr(version_cls_host, cls_name)
+                    self.version_cls = getattr(version_cls_host, cls_name)
                 except:  # noqa
                     raise ValueError(f"Unable to import version_cls='{version_cls}'")
-            self.version_cls = version_cls
+            else:
+                self.version_cls = version_cls
 
     @property
     def fallback_root(self):

src/setuptools_scm/hacks.py

@@ -37,4 +37,5 @@ def fallback_version(root, config=None):
             if version is not None:
                 return meta(str(version), preformatted=True, config=config)
     if config.fallback_version is not None:
+        trace("FALLBACK")
         return meta(config.fallback_version, preformatted=True, config=config)