csspin-python 2.1.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

csspin_python/python.py

@@ -68,6 +68,7 @@ point to the base installation.
 
 import abc
 import configparser
+import hashlib
 import logging
 import os
 import re
@@ -75,6 +76,14 @@ import shutil
 import sys
 from subprocess import check_output
 from textwrap import dedent, indent
+from typing import Iterable, Type, Union
+
+try:
+    from typing import Self  # type: ignore[attr-defined]
+except ImportError:
+    from typing import TypeVar
+
+    Self = TypeVar("Self")  # type: ignore[misc]
 
 from click.exceptions import Abort
 from csspin import (
@@ -144,10 +153,6 @@ defaults = config(
     python="{python.scriptdir}/python{platform.exe}",
     provisioner=None,
     provisioner_memo="{spin.spin_dir}/python_provisioner.memo",
-    current_package=config(
-        install=True,
-        extras=[],
-    ),
     aws_auth=config(
         enabled=False,
         memo="{spin.spin_dir}/aws_auth.memo",
@@ -185,16 +190,16 @@ defaults = config(
 
 
 @task()
-def python(args):
+def python(args: Iterable[object]) -> None:
     """Run the Python interpreter used for this projects."""
     sh("python", *args)
 
 
 @task("python:wheel", when="package")
 def wheel(
-    cfg,
-    paths: argument(type=str, nargs=-1, required=False),  # noqa: F722
-):
+    cfg: ConfigTree,
+    paths: argument(type=str, nargs=-1, required=False),  # type: ignore[valid-type]
+) -> None:
     """Build a wheel of the current project and any additional wheels."""
     setenv(PIP_INDEX_URL=cfg.python.index_url)
     search_paths = paths or cfg.python.build_wheels
@@ -226,8 +231,13 @@ def wheel(
 
 
 @task()
-def env():
-    """Generate command to activate the virtual environment"""
+def env() -> None:
+    """
+    Generate command to activate the virtual environment
+
+    NOTE: spin itself should not be run from within the activated virtual
+          environment!
+    """
     if sys.platform == "win32":
         # Don't care about cmd
         print(normpath("{python.scriptdir}", "activate.ps1"))
@@ -235,12 +245,12 @@ def env():
         print(f". {normpath('{python.scriptdir}', 'activate')}")
 
 
-def pyenv_install(cfg):
+def pyenv_install(cfg: ConfigTree) -> None:
     """Install and setup the virtual environment using pyenv"""
     with namespaces(cfg.python):
         if cfg.python.user_pyenv:
             info("Using your existing pyenv installation ...")
-            sh(f"pyenv install --skip-existing {cfg.python.version}")
+            sh("pyenv", "install", "--skip-existing", {cfg.python.version})
             cfg.python.interpreter = backtick("pyenv which python --nosystem").strip()
         else:
             info("Installing Python {version} to {inst_dir}")
@@ -248,16 +258,18 @@ def pyenv_install(cfg):
             # pyenv is by far the most robust way to install a
             # version of Python.
             if not exists("{pyenv.path}"):
-                sh(f"git clone {cfg.python.pyenv.url} {cfg.python.pyenv.path}")
+                sh("git", "clone", cfg.python.pyenv.url, cfg.python.pyenv.path)
             else:
                 with cd(cfg.python.pyenv.path):
-                    sh("git pull")
+                    sh("git", "pull")
             # we should set
             setenv(PYTHON_BUILD_CACHE_PATH=mkdir(cfg.python.pyenv.cache))
             setenv(PYTHON_CFLAGS="-DOPENSSL_NO_COMP")
             try:
                 sh(
-                    f"{cfg.python.pyenv.python_build} {cfg.python.version} {cfg.python.inst_dir}"
+                    cfg.python.pyenv.python_build,
+                    cfg.python.version,
+                    cfg.python.inst_dir,
                 )
             except Abort:
                 error("Failed to build the Python interpreter - removing it")
@@ -265,7 +277,7 @@ def pyenv_install(cfg):
                 raise
 
 
-def nuget_install(cfg):
+def nuget_install(cfg: ConfigTree) -> None:
     """Install the virtual environment using nuget"""
     if not exists(cfg.python.nuget.exe):
         download(cfg.python.nuget.url, cfg.python.nuget.exe)
@@ -283,7 +295,7 @@ def nuget_install(cfg):
         "-source",
         cfg.python.nuget.source,
     )
-    sh(f"{cfg.python.interpreter} -m ensurepip --upgrade")
+    sh(cfg.python.interpreter, "-m", "ensurepip", "--upgrade")
     sh(
         cfg.python.interpreter,
         "-mpip",
@@ -300,13 +312,11 @@ def provision(cfg: ConfigTree) -> None:
     """Provision the python plugin"""
     with memoizer(cfg.python.provisioner_memo) as memo:
         if cfg.python.provisioner is None:
-            cfg.python.provisioner = SimpleProvisioner()
+            cfg.python.provisioner = SimpleProvisioner(cfg)
         if not memo.check(cfg.python.provisioner):
             memo.add(cfg.python.provisioner)
 
-    info("Checking {python.interpreter}")
     if not shutil.which(cfg.python.interpreter):
-        info("Provisioning '{python.interpreter}'")
         cfg.python.provisioner.provision_python(cfg)
 
     venv_provision(cfg)
@@ -314,7 +324,7 @@ def provision(cfg: ConfigTree) -> None:
     cfg.python.site_packages = get_site_packages(interpreter=cfg.python.python)
 
 
-def configure(cfg):
+def configure(cfg: ConfigTree) -> None:
     """Configure the python plugin"""
     if not cfg.python.version and not cfg.python.use:
         die(
@@ -348,7 +358,7 @@ def configure(cfg):
         _check_aws_token_validity(cfg)
 
 
-def init(cfg):
+def init(cfg: ConfigTree) -> None:
     """Initialize the python plugin"""
     if not cfg.python.use:
         logging.debug("Checking for %s", cfg.python.interpreter)
@@ -365,7 +375,7 @@ def init(cfg):
 ACTIVATED = False
 
 
-def venv_init(cfg):
+def venv_init(cfg: ConfigTree) -> None:
     """Activate the virtual environment"""
     global ACTIVATED  # pylint: disable=global-statement
     if os.environ.get("VIRTUAL_ENV", "") != cfg.python.venv and not ACTIVATED:
@@ -386,7 +396,38 @@ def venv_init(cfg):
         ACTIVATED = True
 
 
-def patch_activate(schema):
+class ActivateScriptPatcher(abc.ABC):
+    activatescript: Union[str, Path]
+    setpattern: str
+    resetpattern: str
+    old_env_pattern: str
+    patchmarker: str
+    replacements: list[tuple[str, str]]
+    script: str
+
+    @staticmethod
+    @abc.abstractmethod
+    def interpolate_environ_value(value: str) -> str:
+        """
+        Translate value so the script can handle uninterpolated "{ENVVAR}" literals in value
+
+        Example:
+        # Assume the following subset of os.environ
+        os.environ = {
+            "PATH": "/bin:/usr/bin",
+            "COMPILER_PATHS": "/compiler/A/bin:/compiler/B/bin",
+        }
+
+        # Now, setenv has been called with
+        # setenv(PATH="{python.scriptdir}:{COMPILER_PATHS}:{PATH}") thus the
+        # value of ``PATH`` in ``EXPORTS`` equals "/venv/bin:{COMPILER_PATHS}:{PATH}" as
+        # ``COMPILER_PATHS`` and ``PATH`` haven't been interpolated yet.
+        interpolate_environ_value(value) => /venv/bin:/compiler/A/bin:/compiler/B/bin:/bin:/usr/bin
+        """
+        return value
+
+
+def patch_activate(schema: Type[ActivateScriptPatcher]) -> None:
     """Patch the activate script"""
     if exists(schema.activatescript):
         setters = []
@@ -397,9 +438,9 @@ def patch_activate(schema):
             setters.append(schema.setpattern.format(name=name, value=value))
             resetters.add(schema.resetpattern.format(name=name))
             old_value_setters.add(schema.old_env_pattern.format(name=name))
-        resetters = "\n".join(resetters)
-        setters = "\n".join(setters)
-        old_value_setters = "\n".join(old_value_setters)
+        resetters_string = "\n".join(resetters)
+        setters_string = "\n".join(setters)
+        old_value_setters_string = "\n".join(old_value_setters)
         original = readtext(schema.activatescript)
         if schema.patchmarker not in original:
             shutil.copyfile(
@@ -418,36 +459,13 @@ def patch_activate(schema):
         newscript = schema.script.format(
             patchmarker=schema.patchmarker,
             original=original,
-            resetters=resetters,
-            old_value_setters=old_value_setters,
-            setters=setters,
+            resetters=resetters_string,
+            old_value_setters=old_value_setters_string,
+            setters=setters_string,
         )
         writetext(f"{schema.activatescript}", newscript)
 
 
-class ActivateScriptPatcher(abc.ABC):
-    @staticmethod
-    @abc.abstractmethod
-    def interpolate_environ_value(value):
-        """
-        Translate value so the script can handle uninterpolated "{ENVVAR}" literals in value
-
-        Example:
-        # Assume the following subset of os.environ
-        os.environ = {
-            "PATH": "/bin:/usr/bin",
-            "COMPILER_PATHS": "/compiler/A/bin:/compiler/B/bin",
-        }
-
-        # Now, setenv has been called with
-        # setenv(PATH="{python.scriptdir}:{COMPILER_PATHS}:{PATH}") thus the
-        # value of ``PATH`` in ``EXPORTS`` equals "/venv/bin:{COMPILER_PATHS}:{PATH}" as
-        # ``COMPILER_PATHS`` and ``PATH`` haven't been interpolated yet.
-        interpolate_environ_value(value) => /venv/bin:/compiler/A/bin:/compiler/B/bin:/bin:/usr/bin
-        """
-        return value
-
-
 class BashActivate(ActivateScriptPatcher):
     patchmarker = "\n## Patched by csspin_python.python\n"
     activatescript = Path("{python.scriptdir}") / "activate"
@@ -510,7 +528,7 @@ class BashActivate(ActivateScriptPatcher):
     )
 
     @staticmethod
-    def interpolate_environ_value(value):
+    def interpolate_environ_value(value: str) -> str:
         if not value:
             return ""
         keys = re.findall(r"{(?P<key>\w+?)}", value)
@@ -564,7 +582,7 @@ class PowershellActivate(ActivateScriptPatcher):
     )
 
     @staticmethod
-    def interpolate_environ_value(value):
+    def interpolate_environ_value(value: str) -> str:
         if not value:
             return ""
         keys = re.findall(r"{(?P<key>\w+?)}", value)
@@ -577,7 +595,7 @@ class PowershellActivate(ActivateScriptPatcher):
 class BatchActivate(ActivateScriptPatcher):
     patchmarker = "\nREM Patched by csspin_python.python\n"
     activatescript = Path("{python.scriptdir}") / "activate.bat"
-    replacements = ()
+    replacements = []
     old_env_pattern = dedent(
         """
         if defined _OLD_SPIN_VALUE_{name} goto ENDIFSPIN{name}1
@@ -614,7 +632,7 @@ class BatchActivate(ActivateScriptPatcher):
     )
 
     @staticmethod
-    def interpolate_environ_value(value):
+    def interpolate_environ_value(value: str) -> str:
         if not value:
             return ""
         keys = re.findall(r"{(?P<key>\w+?)}", value)
@@ -627,7 +645,7 @@ class BatchActivate(ActivateScriptPatcher):
 class BatchDeactivate(ActivateScriptPatcher):
     patchmarker = "\nREM Patched by csspin_python.python\n"
     activatescript = Path("{python.scriptdir}") / "deactivate.bat"
-    replacements = ()
+    replacements = []
     old_env_pattern = ""
     setpattern = ""
     resetpattern = dedent(
@@ -658,7 +676,7 @@ class BatchDeactivate(ActivateScriptPatcher):
 class PythonActivate(ActivateScriptPatcher):
     patchmarker = "# Patched by csspin_python.python\n"
     activatescript = Path("{python.scriptdir}") / "activate_this.py"
-    replacements = ()
+    replacements = []
     old_env_pattern = ""
     setpattern = 'os.environ["{name}"] = fr"{value}"'
     resetpattern = ""
@@ -671,7 +689,7 @@ class PythonActivate(ActivateScriptPatcher):
     )
 
     @staticmethod
-    def interpolate_environ_value(value):
+    def interpolate_environ_value(value: str) -> str:
         if not value:
             return ""
         keys = re.findall(r"{(?P<key>\w+?)}", value)
@@ -681,7 +699,7 @@ class PythonActivate(ActivateScriptPatcher):
         return value
 
 
-def get_site_packages(interpreter):
+def get_site_packages(interpreter: Path) -> Path:
     """Return the path to the virtual environments site-packages."""
     return Path(
         check_output(
@@ -696,7 +714,7 @@ def get_site_packages(interpreter):
     )
 
 
-def finalize_provision(cfg):
+def finalize_provision(cfg: ConfigTree) -> None:
     """Patching the activate scripts and preparing the site-packages"""
     cfg.python.provisioner.install(cfg)
 
@@ -723,7 +741,7 @@ def finalize_provision(cfg):
 
 class ProvisionerProtocol:
     """An implementation of this protocol is used to provision
-    dependencies to a virtual environment.
+    requirements to a virtual environment.
 
     Separate plugins, can implement this interface and overwrite
     cfg.python.provisioner.
@@ -732,8 +750,9 @@ class ProvisionerProtocol:
     The provisioner will be memoized, so make sure it works with ``pickle.dumps``.
     """
 
-    # noinspection PyMethodMayBeStatic
-    def provision_python(self, cfg: ConfigTree) -> None:
+    _requirements: set[str] = set()
+
+    def provision_python(self: Self, cfg: ConfigTree) -> None:
         """Provision the project's python interpreter"""
         if sys.platform == "win32":
             nuget_install(cfg)
@@ -742,10 +761,8 @@ class ProvisionerProtocol:
             pyenv_install(cfg)
 
     # noinspection PyMethodMayBeStatic
-    def provision_venv(self, cfg: ConfigTree) -> None:
+    def provision_venv(self: Self, cfg: ConfigTree) -> None:
         """Provision the virtual environment of the project"""
-        # virtualenv is guaranteed to be available like this
-        # as we declared it as one of spin's dependencies
         cmd = [
             sys.executable,
             "-mvirtualenv",
@@ -761,43 +778,44 @@ class ProvisionerProtocol:
             env={"PYTHONPATH": cfg.spin.spin_dir / "plugins"},
         )
 
-    def prerequisites(self, cfg: ConfigTree) -> None:
+    def prerequisites(self: Self, cfg: ConfigTree) -> None:
         """Provide requirements for the provisioning strategy."""
 
-    def lock(self, cfg: ConfigTree) -> None:
-        """Lock the project's dependencies."""
-
-    def add(self, cfg: ConfigTree, req: str, devpackage: bool = False) -> None:
-        """Add an extra dependency (incl. development ones)."""
-
-    def lock_extras(self, cfg: ConfigTree) -> None:
-        """Lock the extra dependencies."""
-
-    def sync(self, cfg: ConfigTree) -> None:
-        """Synchronize the environment with the locked dependencies."""
+    def add(
+        self: Self, cfg: ConfigTree, req: str  # pylint: disable=unused-argument
+    ) -> None:
+        """
+        Add a single requirement `req`, that will be installed into the
+        environment.
+        """
+        self._requirements.add(req)
 
-    def install(self, cfg: ConfigTree) -> None:
-        """Install the project itself."""
+    def install(self: Self, cfg: ConfigTree) -> None:
+        """Install the requirements"""
 
-    # noinspection PyMethodMayBeStatic
-    def cleanup(self, cfg: ConfigTree) -> None:
+    def cleanup(self: Self, cfg: ConfigTree) -> None:
         """Cleanup the provisioned environment"""
         rmtree(cfg.python.venv)
 
 
 class SimpleProvisioner(ProvisionerProtocol):
-    """The simplest Python dependency provisioner using pip.
+    """
+    The simplest Python provisioner, using pip.
 
-    This provisioner will never uninstall dependencies that are no
-    longer required.
+    This provisioner will never uninstall requirements that are no longer
+    required.
     """
 
-    def __init__(self):
-        self.requirements = set()
-        self.devpackages = set()
-        self.m = Memoizer("{python.memo}")
+    def __init__(self: Self, cfg: ConfigTree) -> None:
+        self._m = Memoizer(interpolate1("{python.memo}"))
+        self._install_command = Command(
+            "pip",
+            None if cfg.verbosity > Verbosity.NORMAL else "-q",
+            "--disable-pip-version-check",
+            "install",
+        )
 
-    def prerequisites(self, cfg):
+    def prerequisites(self: Self, cfg: ConfigTree) -> None:
         # We'll need pip
         sh(
             "python",
@@ -811,82 +829,97 @@ class SimpleProvisioner(ProvisionerProtocol):
             "pip",
         )
 
-    def lock(self, cfg):
-        """Noop"""
+    def install(self: Self, cfg: ConfigTree) -> None:
+        if requirements := self._filter(
+            self._requirements, self._m, cfg.spin.project_root
+        ):
+            self._install_command(*self._split(requirements))
+            self._m.clear()
+            for req in requirements:
+                self._m.add(_req_for_memo(req, cfg.spin.project_root))
 
-    def add(self, cfg, req, devpackage=False):
-        # Add the requirement or devpackage if not already there.
-        if not self.m.check(req):
-            lst = self.devpackages if devpackage else self.requirements
-            lst.add(req)
+    @staticmethod
+    def _split(requirements: Iterable[str]) -> list[str]:
+        """Used to pass whitespace-less args to :func:`csspin.sh()`."""
+        requirement_list = []
+        for requirement in requirements:
+            requirement_list.extend(requirement.split())
+        return requirement_list
 
-    def sync(self, cfg):
-        self.__execute_installation(
-            self.requirements,
-            None if cfg.verbosity > Verbosity.NORMAL else "-q",
-            cfg.python.index_url,
-        )
+    @staticmethod
+    def _filter(
+        requirements: set[str], memo: Memoizer, project_root: Union[Path, str]
+    ) -> set[str]:
+        """
+        We want to filter all requirements prior to installing them, because we
+        only want to run the install, when there are changes, as it takes pip
+        quite some time to check, whether it has to do something.
+        """
+        if all(memo.check(_req_for_memo(req, project_root)) for req in requirements):
+            return set()
+        else:
+            return requirements
 
-    def install(self, cfg):
-        quietflag = None if cfg.verbosity > Verbosity.NORMAL else "-q"
-        self.__execute_installation(self.devpackages, quietflag, cfg.python.index_url)
 
-        # If there is a setup.py, make an editable install (which
-        # transitively also installs runtime dependencies of the project).
-        if cfg.python.current_package.install and any(
-            (exists("setup.py"), exists("setup.cfg"), exists("pyproject.toml"))
-        ):
-            cmd = [
-                "pip",
-                quietflag,
-                "--disable-pip-version-check",
-                "install",
-                "--index-url",
-                cfg.python.index_url,
-                "-e",
-            ]
-            if cfg.python.current_package.extras:
-                cmd.append(f".[{','.join(cfg.python.current_package.extras)}]")
-            else:
-                cmd.append(".")
-            sh(*cmd)
+def _file_hash(filename: Union[Path, str]) -> str:
+    """
+    Calculate a sha256 hash of a file's content and return its hexdigest.
+    """
+    with open(filename, mode="br") as fd:
+        return hashlib.sha256(fd.read()).hexdigest()  # nosec: hashlib
 
-        # Verify dependency compatibility of installed packages
-        pip_check = sh(
-            "pip",
-            "--disable-pip-version-check",
-            "check",
-            check=False,
-            capture_output=True,
-        )
-        if pip_check.returncode:
-            die(pip_check.stdout)
-
-    def _split(self, reqset):
-        """to pass whitespace-less args to sh()"""
-        reqlist = []
-        for req in reqset:
-            reqlist.extend(req.split())
-        return reqlist
-
-    def __execute_installation(self, packages, quietflag, index_url):
-        """Install packages that are not yet memoized"""
-        if to_install := {package for package in packages if not self.m.check(package)}:
-            sh(
-                "pip",
-                quietflag,
-                "--disable-pip-version-check",
-                "install",
-                "--index-url",
-                index_url,
-                *self._split(to_install),
-            )
-            for package in to_install:
-                self.m.add(package)
-            self.m.save()
 
+def _split_requirement_option(req: str, project_root: Path) -> Union[Path, None]:
+    """
+    Takes an element of ``python.requirements`` and checks if it
+    is an argument for pip that contains a filename. If so,
+    the filename will be returned, ``None`` otherwise.
+
+    The following options are respected:
+        - ``-r``/``--requirement``
+        - ``-c``/``--constraint``
 
-def venv_provision(cfg):  # pylint: disable=too-many-branches,missing-function-docstring
+    If a file for an option cannot be found, the plugin will
+    :func:`csspin.die()`.
+    """
+    if (
+        req.startswith(option := "-r")
+        or req.startswith(option := "--requirement")
+        or req.startswith(option := "-c")
+        or req.startswith(option := "--constraint")
+    ):
+        # The pattern has to enforce the " "/"=" for the long-options
+        match_many = "+" if option.startswith("--") else "*"
+        pattern = rf"{option}[ =]{match_many}(?P<filename>.*)"
+        match = re.match(pattern, req)
+        if not match:
+            die(f"{req} could not be validated.")
+        else:
+            file = project_root / match.group("filename")
+            if not file.exists():
+                die(f"{file} does not exist.")
+            return file
+    return None
+
+
+def _req_for_memo(
+    req: str, project_root: Union[Path, str]
+) -> str:  # pylint: disable=inconsistent-return-statements
+    """
+    Return a memoizable representation of a python requirement. In case a
+    requirement is on of the following options, the function returns requirement
+    with a hash of the files' content appended. Otherwise the requirement itself
+    will be returned.
+    """
+    if file := _split_requirement_option(req, project_root):
+        return f"{req}{_file_hash(file)}"
+    else:
+        return req
+
+
+def venv_provision(  # pylint: disable=too-many-branches,missing-function-docstring
+    cfg: ConfigTree,
+) -> None:
     fresh_env = False
 
     info("Checking venv '{python.venv}'")
@@ -916,16 +949,10 @@ def venv_provision(cfg):  # pylint: disable=too-many-branches,missing-function-d
             logging.debug(f"{plugin_module.__name__}.venv_hook()")
             hook(cfg)
 
-    cfg.python.provisioner.lock(cfg)
-
-    # Install packages required by the project ('requirements')
+    # Add packages required by the project ('requirements')
     for req in cfg.python.get("requirements", []):
         cfg.python.provisioner.add(cfg, interpolate1(req))
 
-    # Install development packages required by the project ('devpackages')
-    for pkgspec in cfg.python.get("devpackages", []):
-        cfg.python.provisioner.add(cfg, interpolate1(pkgspec), True)
-
     # Install packages required by plugins used
     # ('<plugin>.requires.python')
     for plugin in cfg.spin.topo_plugins:
@@ -933,9 +960,6 @@ def venv_provision(cfg):  # pylint: disable=too-many-branches,missing-function-d
         for req in get_requires(plugin_module.defaults, "python"):
             cfg.python.provisioner.add(cfg, interpolate1(req))
 
-    cfg.python.provisioner.lock_extras(cfg)
-    cfg.python.provisioner.sync(cfg)
-
 
 def cleanup(cfg: ConfigTree) -> None:
     """Remove directories and files generated by the python plugin."""
@@ -961,7 +985,7 @@ def cleanup(cfg: ConfigTree) -> None:
                 rmtree(current_path / filename)
 
 
-def _get_pipconf(cfg):
+def _get_pipconf(cfg: ConfigTree) -> Path:
     """Retrieve the pipconf configuration file path."""
     if sys.platform == "win32":
         pipconf = interpolate1(Path(cfg.python.venv)) / "pip.ini"
@@ -971,7 +995,7 @@ def _get_pipconf(cfg):
     return pipconf
 
 
-def _configure_pipconf(cfg, update=False):
+def _configure_pipconf(cfg: ConfigTree, update: bool = False) -> None:
     """Configure the pip configuration file"""
     config_parser = configparser.ConfigParser()
     config_parser.read_string(cfg.python.pipconf)
@@ -985,7 +1009,7 @@ def _configure_pipconf(cfg, update=False):
         config_parser.write(fd)
 
 
-def _obfuscate_index_url(index_url):
+def _obfuscate_index_url(index_url: str) -> None:
     """Add the CodeArtifact token to the secrets."""
 
     from csspin import secrets
@@ -993,7 +1017,7 @@ def _obfuscate_index_url(index_url):
     secrets.add(index_url.split(":")[2].split("@")[0])  # Codeartifact token
 
 
-def _check_aws_token_validity(cfg):
+def _check_aws_token_validity(cfg: ConfigTree) -> None:
     """
     If csspin-python[aws_auth] is installed, we can use csaccess to get the
     CodeArtifact authentication token.
@@ -1016,7 +1040,9 @@ def _check_aws_token_validity(cfg):
         for item in memo.items():
             if isinstance(item, str) and item.startswith(f"{timestamp_key}:"):
                 last_time = int(item.split(":", 1)[1])
-                if current_time - last_time < cfg.python.aws_auth.key_duration:
+                if current_time - last_time < int(
+                    interpolate1(cfg.python.aws_auth.key_duration)
+                ):
                     pipconf = _get_pipconf(cfg)
                     config_parser = configparser.ConfigParser()
                     config_parser.read(pipconf)
@@ -1034,12 +1060,18 @@ def _check_aws_token_validity(cfg):
             info("Updating Codeartifact token.")
             from urllib.parse import urljoin
 
+            opts = {
+                "static_oidc": interpolate1(cfg.python.aws_auth.static_oidc).lower()
+                == "true"
+            }
+            if cfg.python.aws_auth.client_id:
+                opts["client_id"] = interpolate1(cfg.python.aws_auth.client_id)
+            if cfg.python.aws_auth.role_arn:
+                opts["aws_role_arn"] = interpolate1(cfg.python.aws_auth.role_arn)
+
+            index_base_url = get_ca_pypi_url_programmatic(**opts)
             index_url = urljoin(
-                get_ca_pypi_url_programmatic(
-                    static_oidc=cfg.python.aws_auth.static_oidc
-                )
-                + "/",
-                cfg.python.aws_auth.index,
+                index_base_url + "/", interpolate1(cfg.python.aws_auth.index)
             )
             cfg.python.index_url = index_url
             _obfuscate_index_url(index_url)