htpolynet 2.3.0__tar.gz → 2.3.1__tar.gz

{htpolynet-2.3.0 → htpolynet-2.3.1}/CHANGELOG.md

@@ -7,6 +7,63 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.3.1] - 2026-08-25
+
+### Fixed
+
+- **`htpolynet postsim` and `htpolynet analyze` no longer die in a directory
+  without a `lib/`.**  Both took `-lib` with a default of `'lib'`, but only
+  `htpolynet run` creates that tree, so the default value of a flag the user
+  never typed reached `UserLibrary` and tripped its existence assertion:
+  `AssertionError: lib is not a directory`, three seconds in.  The documented
+  container invocation failed on it -- running `postsim` against a staged
+  directory holding only finished results, which is the normal shape of a
+  cluster workflow, where the cure ran somewhere else.
+
+  `-lib` now defaults to nothing for these two subcommands, and the
+  conventional `./lib` is used when it happens to be there.  An explicitly
+  supplied `-lib` is still validated, so a typo fails loudly rather than
+  silently degrading to no library.  The assertion message now names the flag
+  and the resolved path instead of echoing a bare `lib` the user never
+  supplied.
+
+### Changed
+
+- Documented that **the density at the end of `postcure` is not an
+  equilibrated density**, in the `postcure` directive reference and at the
+  point in the example 6 tutorial where a reader would take a number off the
+  plot.  A crosslinked network relaxes only above its glass transition, and
+  a postcure anneal peaking near *Tg* spends almost no time where the
+  network can move, so the plateau reports an under-relaxed structure
+  however long the plateau runs.  Measured on four independent BPA builds:
+  the plateau gives 1.1712 +/- 0.0029 g/cm3 against 1.1983 +/- 0.0037 for
+  the same systems melted and slowly re-cooled -- 2.31% apart, with the
+  plateau 2.6-2.8% below experiment and the re-cooled value within 1%.
+  Nothing is computed incorrectly; the protocol simply does not equilibrate
+  what a reader would assume it does.  The example's own anneal peak is
+  unchanged pending a test that raising it actually helps; see `ROADMAP.md`.
+
+- `htpolynet info` no longer reports `HTPolyNet git commit: unknown` for an
+  installed copy.  pip, conda and the published container have no `.git`
+  beside the package, so the lookup could never succeed and a build had no
+  way to identify its own code from inside itself -- the same question the
+  parameterization records answer for molecules.  It now falls back to the
+  installed distribution version, which for a released install maps to a tag.
+
+- The warnings about a cached parameterization with no provenance record
+  now say that the cached values are being **used**, not merely that they
+  could not be checked.  The old wording ("cannot be checked against the
+  requested 'bcc' charge method") left the decisive fact implicit: the
+  build proceeds with whatever charges that entry holds.  A user who
+  upgrades with an existing library, asks for `bcc` and measures `gas`
+  numbers would reasonably conclude the 2.3.0 cache guard does not work --
+  correct behavior is otherwise indistinguishable from the bug it replaced.
+  Both the per-molecule line and the stage-end block now state that the
+  build carries the cached charges, that they may not match the requested
+  method, and that this is expected for a pre-2.3 entry rather than a
+  failure.  The same clarification is made in the user guide and the
+  `ambertools` directive reference.
+
 ## [2.3.0] - 2026-08-23
 
 ### Fixed

{htpolynet-2.3.0 → htpolynet-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: htpolynet
-Version: 2.3.0
+Version: 2.3.1
 Summary: Automated MD System Builder for Amorphous Network Polymers
 Project-URL: Source, https://github.com/cameronabrams/htpolynet
 Project-URL: Documentation, https://htpolynet.readthedocs.io/

{htpolynet-2.3.0 → htpolynet-2.3.1}/ROADMAP.md

@@ -27,6 +27,36 @@ Rough ordering within each section is by value, not by effort.
   every week via the scheduled rebuild, so a run recorded as "built with
   the container" is not reproducible. Per-commit tags already exist;
   what's missing is documenting that users should pin one.
+
+- **The container cannot report which commit built it, and its version
+  string is actively misleading between releases.** `htpolynet info` used to
+  print `git commit: unknown` inside the image, because `_get_git_commit()`
+  runs `git rev-parse` against the installed package directory and no
+  installed copy has a `.git` beside it. That now falls back to the
+  installed distribution version, which is right for a pip or conda install
+  and *precisely wrong for the container*: the scheduled rebuild builds from
+  `main` HEAD, which can be many commits past the last tag, so the image
+  reports its `pyproject.toml` version honestly while running code that is
+  not that version.
+
+  This is live, not hypothetical. The 2026-08-24 03:54 scheduled build moved
+  `:latest` to an image built from `948c301` -- four commits past `v2.3.0`
+  -- and that image reports `installed version 2.3.0`. `:latest` is the
+  default thing a user pulls and the weekly cron is what keeps moving it, so
+  the wrong answer is the common case, and it is wrong silently. A user
+  could pull `:latest`, trust the version string, and write "htpolynet
+  2.3.0" in a methods section while having run untagged `main`.
+
+  The fix is to bake the real commit in at image build time -- the build
+  context has `.git`, so `docker.yml` or the Dockerfile can capture
+  `git rev-parse HEAD` and write it where the package can read it. That
+  touches the Dockerfile and the release story together, which is why it was
+  kept out of the bugfix that added the version fallback. It belongs with
+  the build-manifest entry below: both answer "what produced this build",
+  and a manifest that recorded an unreliable version string would launder
+  the problem rather than solve it. Raised by the calibration study, which
+  has correct provenance only because it pins the image by full sha
+  externally -- which remains the right practice either way.
 - **Retire `ghcr.io/abramsgroup/htpolynet`.** Superseded by the
   `cameronabrams` package; still public and still serving a June image to
   anyone with an old link.
@@ -122,6 +152,56 @@ Coverage as of the last measurement: **38.8%** overall.
   cyanate-ester bridge series meant doing (a) and (b) by hand in a throwaway
   RDKit script, which is exactly the work a user should not have to
   reinvent.
+- **The bundled Claude skill only reaches people working in a clone.**
+  `.claude/skills/htpolynet/` is picked up when the working directory is the
+  repository, which covers contributors and anyone who cloned to run the
+  examples -- but not the ordinary user who `pip install`s or
+  `conda install`s htpolynet and works in their own project directory, which
+  is most of them. Whether to ship it inside the package is undecided.
+
+  Two things to settle before doing so, neither obvious:
+
+  1. **The skill would be broken as written.** Its central move is "read
+     `docs/source/user-guide/building-a-system.rst`", a repo path that does
+     not exist for an installed user. A shipped version would have to point
+     at the Read the Docs URL instead, or the guide would have to ship as
+     package data. The first is simpler and goes stale differently -- an RTD
+     link tracks `latest`, so an installed 2.3.0 would send its reader to
+     documentation for whatever is current.
+  2. **Delivery.** A skill file inside a wheel does nothing on its own;
+     something has to place it where the tool looks. An `htpolynet skill
+     --install` subcommand copying it into the user's `~/.claude/skills/`
+     is the obvious mechanism, and is also the point at which a scientific
+     package starts carrying vendor-specific tooling and an install-time
+     side effect on a directory it does not own.
+
+  Worth weighing against simply doing nothing: the procedural guide the skill
+  points at is on Read the Docs already, and an agent that reads
+  documentation gets the same content without any of this.
+
+- **Generated topologies cannot be compared byte-wise, because ParmEd
+  stamps them.** Every `.top` htpolynet writes opens with a ParmEd header
+  recording the invoking user, the host, and the date:
+
+      ;   File TAZ.top  was generated
+      ;   By user: cfa (1000)
+      ;   On host: panacea.chemeng.drexel.edu
+      ;   At date: Fri. May  5 15:55:38 2026
+
+  So two physically identical parameterizations never hash the same, and the
+  obvious check -- "did these two builds produce the same parameters for the
+  shared monomers?" -- returns a false difference. The calibration study hit
+  this on its bridge series and nearly reported the series confounded on the
+  strength of an md5; the fix on their side was to strip comment lines before
+  comparing, which every user will have to reinvent. Note the header is
+  itself provenance, but the wrong kind: it records *when and where* rather
+  than *what directives*, which is what the `parm` record now covers, and it
+  actively prevents the comparison you would want. The `.itp` files carry no
+  such header and the `parm` records are JSON with sorted keys, so both
+  already compare cleanly. Worth either normalizing the `.top` header away or
+  shipping a comparison helper; this belongs with the manifest entry below,
+  since both are about being able to answer "is this the same build?".
+
 - **`-lib` is read-only, and nothing says so.** `pfs.checkout()` and
   `pfs.exists()` consult the `-lib` user library first, then the user cache,
   then the system library -- but `pfs.checkin()` writes unconditionally to the
@@ -234,6 +314,44 @@ Coverage as of the last measurement: **38.8%** overall.
 
 ## Example depot
 
+- **Example 6's postcure anneal peaks too close to *T*:sub:`g` to relax the
+  network, and the fix is not simply "run it longer".** Measured on four
+  independent BPA builds: the postcure NPT plateau gives 1.1712 ± 0.0029
+  g/cm³ where the same systems melted and slowly re-cooled give 1.1983 ±
+  0.0037 g/cm³ -- 2.31% apart, with the plateau 2.6-2.8% below experiment
+  and the re-cooled value within 1%. The plateau is an under-relaxed
+  structure.
+
+  The mechanism, and the reason the obvious fix is the wrong one: the
+  example anneals at a 500 K peak, and the measured *T*:sub:`g` for this
+  system is 487.9 K. That is 12.1 K above the glass transition, for 80 ps.
+  The Tg ladder that produced the relaxed value spent 15,785 ps above
+  *T*:sub:`g`, peaking 112 K above it -- 197x the time, in the only regime
+  where a crosslinked network moves at all. Lengthening an anneal that sits
+  12 K above *T*:sub:`g` extends a process that barely moves anything, so
+  the lever is the peak temperature, not the duration.
+
+  **Untested.** Nobody has yet built with a hotter anneal and compared it
+  against the melt-and-recool value, which is the experiment that would
+  settle it; the argument above is mechanism, not measurement. That is why
+  the example is documented rather than changed. Raising the peak also costs
+  wall-clock in a tutorial that should stay small, so the test needs to
+  report both whether it works and what it costs.
+
+  The general problem is worth more than the instance: **any protocol whose
+  relaxation depends on being above *T*:sub:`g` is fragile when *T*:sub:`g`
+  is unknown at configuration time**, which it always is -- you cannot know
+  it before building the thing. A fixed absolute peak temperature is a guess
+  that happens to be right or wrong per chemistry, silently. Something
+  expressed relative to an estimated or measured *T*:sub:`g`, or a postcure
+  that measures *T*:sub:`g` and then anneals accordingly, would be robust
+  where an absolute number is not. That is a real design change, not a
+  config edit.
+
+  Raised by the calibration study, which had already published the
+  pessimistic density before catching it -- the failure mode is reporting a
+  protocol artifact as a force-field result.
+
 - **Example 5 is still not laptop-scale.** The `68d81fb` retune cut the
   monomer pool to make HTPB/IPDI "fit in a reasonable wall time on a
   laptop", but a validation run on 16 CPU cores took **10h17m** — about

{htpolynet-2.3.0 → htpolynet-2.3.1}/docs/source/example-tutorials/6-cyanate-ester/postsim.rst

@@ -87,6 +87,22 @@ Run it:
 Density during annealing and equilibration
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+.. warning::
+
+   The density this stage settles at is **not** an equilibrated density.
+   This example's postcure anneal peaks at 500 K, and the measured
+   *T*:sub:`g` for this system is about 488 K -- so the anneal spends its
+   80 ps of peak time only ~12 K above the glass transition, where a
+   crosslinked network barely moves.  On four independent builds the
+   postcure plateau came out 2.31% below the same systems' density after a
+   melt and slow re-cool, and 2.6-2.8% below experiment, where the
+   re-cooled value agrees with experiment to under 1%.
+
+   The 500 K peak is fine for this tutorial's purpose, which is to show the
+   workflow.  It is not a basis for quoting a density.  Take densities from
+   the cooling ladder below instead.
+
+
 .. admonition:: Placeholder
    :class: caution
 

{htpolynet-2.3.0 → htpolynet-2.3.1}/docs/source/user-guide/configs/configs-for-run.rst

@@ -61,7 +61,7 @@ In this section we show all subdirectives for each of the five main directives i
 
     These three directives determine the parameters ``antechamber`` produces, so each parameterization records them in a ``.parm`` file checked into the library alongside its ``gro``, ``top``, ``itp``, ``tpx`` and ``grx`` files.  Because the library is keyed on molecule name, that record is the only thing distinguishing a molecule parameterized one way from the same molecule parameterized another.  A run whose directives disagree with the record re-parameterizes rather than reusing the cached files, and says which directives differed.
 
-    A parameterization checked in before htpolynet 2.3 has no such record.  It is still used, but the run warns that it cannot verify what produced it; rebuild it with ``--force-parameterization`` if you need to be sure.  Note that re-parameterizing after a mismatch does **not** replace the library entry unless you also pass ``--force-checkin``, so a library holding a ``gas`` parameterization keeps it even after a ``bcc`` run.
+    A parameterization checked in before htpolynet 2.3 has no such record.  It is still used **as-is**, which means the build takes whatever charges that entry holds even if they were produced with a different ``charge_method``; the run warns, per molecule and again in a block at the end of the parameterization stage, that it could not verify what produced them.  This is deliberate -- it keeps an existing library working instead of re-parameterizing it wholesale -- but it does mean that asking for ``bcc`` against a pre-2.3 library can still yield ``gas`` numbers.  Rebuild those entries with ``--force-parameterization`` if a build's charges need to be certain.  Note that re-parameterizing after a mismatch does **not** replace the library entry unless you also pass ``--force-checkin``, so a library holding a ``gas`` parameterization keeps it even after a ``bcc`` run.
 
 * ``GAFF``
 
@@ -263,6 +263,14 @@ In this section we show all subdirectives for each of the five main directives i
 
     The ``postcure`` directive instructs ``htpolynet`` on running a series of MD simulations after cure.  Its form is identical to that of ``precure``, namely with optional ``preequilibration``, ``anneal``, and ``postequilibration`` subdirectives.
 
+    .. warning::
+
+       **The density at the end of ``postequilibration`` is not an equilibrated density, and should not be quoted as one.**  A crosslinked network only relaxes appreciably above its glass transition, and a postcure anneal whose peak sits near *T*:sub:`g` spends very little time where the network can move -- so the postcure plateau reports an under-relaxed structure no matter how long the plateau itself runs.
+
+       Measured on four independent BPA cyanate-ester builds: the postcure NPT plateau gave 1.1712 ± 0.0029 g/cm³ at 300 K, while the same systems melted and slowly re-cooled gave 1.1983 ± 0.0037 g/cm³ at 293 K -- a 2.31% difference between two extractions of the same quantity.  Against experiment (1.205 by mercury dilatometry, 1.202 by flotation, same monomer), the plateau value is 2.6-2.8% low and the re-cooled value 0.3-0.6% low.  A build reporting the plateau density would have read as a force-field failure when it was a protocol artifact.
+
+       If you need a density, extract it from a melt-and-slow-cool trajectory (an :doc:`htpolynet postsim <configs-for-postsim>` ladder does this) rather than from the postcure plateau.  The same caution applies to any property that depends on the structure having relaxed.
+
 .. _reactions:
 
 * ``reactions``

{htpolynet-2.3.0 → htpolynet-2.3.1}/docs/source/user-guide/usage.rst

@@ -222,8 +222,9 @@ checked in under the same name.
 .. note::
 
    A parameterization checked in before htpolynet 2.3 carries no record.
-   Those entries are still used, so an existing cache keeps working, but
-   each one logs a warning that its provenance could not be verified, and
+   Those entries are still used **as-is**, so an existing cache keeps
+   working — but the build takes whatever charges they hold, which may not
+   be what your ``charge_method`` asks for.  Each one logs a warning, and
    the parameterization stage ends with a block listing them all.  Rebuild
    them with ``--force-parameterization`` if you need certainty about what
    a build used.
@@ -387,7 +388,9 @@ The purpose of the ``postsim`` subcommand is to control the execution of several
     -h, --help            show this help message and exit
     -proj PROJ [PROJ ...]
                           name of project directory
-    -lib LIB              local user library of molecular structures and parameterizations
+    -lib LIB              local user library of molecular structures and
+                          parameterizations (default: ./lib if it exists,
+                          otherwise none)
     -ocfg OCFG            original htpolynet config file used to generate project(s)
     -cfg CFG              config file specifying the operations to perform
     --no-banner           suppress the startup banner
@@ -410,7 +413,9 @@ The ``analyze`` subcommand provides a shortcut interfaces to selected ``gmx``-st
     -h, --help            show this help message and exit
     -proj PROJ [PROJ ...]
                           name of project directory
-    -lib LIB              local user library of molecular structures and parameterizations
+    -lib LIB              local user library of molecular structures and
+                          parameterizations (default: ./lib if it exists,
+                          otherwise none)
     -ocfg OCFG            original htpolynet config file used to generate project(s)
     -cfg CFG              config file specifying the operations to perform
     --no-banner           suppress the startup banner

{htpolynet-2.3.0 → htpolynet-2.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "htpolynet"
-version = "2.3.0"
+version = "2.3.1"
 authors = [
   { name="Cameron F Abrams", email="cfa22@drexel.edu" },
 ]

{htpolynet-2.3.0 → htpolynet-2.3.1}/src/htpolynet/analysis/analyze.py

@@ -248,7 +248,7 @@ def analyze(args):
     software.sw_setup()
     logger.debug(f'ogromacs {ogromacs}')
     for d in args.proj:
-        pfs.pfs_setup(root=os.getcwd(),topdirs=pfs.Dirs.analyze_topdirs,verbose=True,projdir=d,reProject=False,userlibrary=args.lib)
+        pfs.pfs_setup(root=os.getcwd(),topdirs=pfs.Dirs.analyze_topdirs,verbose=True,projdir=d,reProject=False,userlibrary=pfs.resolve_user_library(args.lib))
         pfs.go_to(pfs.Dirs.analyze)
         for stage in cfg.stagelist:
             stage.do(**ogromacs)

{htpolynet-2.3.0 → htpolynet-2.3.1}/src/htpolynet/analysis/postsim.py

@@ -436,7 +436,7 @@ def postsim(args):
     software.sw_setup()
     logger.debug(f'ogromacs {ogromacs}')
     for d in args.proj:
-        pfs.pfs_setup(root=os.getcwd(),topdirs=pfs.Dirs.postsim_topdirs,verbose=True,projdir=d,reProject=False,userlibrary=args.lib)
+        pfs.pfs_setup(root=os.getcwd(),topdirs=pfs.Dirs.postsim_topdirs,verbose=True,projdir=d,reProject=False,userlibrary=pfs.resolve_user_library(args.lib))
         pfs.go_to(pfs.Dirs.postsim)
         for stage in cfg.stagelist:
             stage.do(mdp_pfx='local',**ogromacs)

{htpolynet-2.3.0 → htpolynet-2.3.1}/src/htpolynet/cli.py

@@ -235,7 +235,7 @@ def _add_gen_slurm_args(p):
 def _add_analysis_args(p):
     """Adds the common arguments shared by the postsim and analyze subcommands."""
     p.add_argument('-proj',type=str,default='',nargs='+',help='name of project directory')
-    p.add_argument('-lib',type=str,default='lib',help='local user library of molecular structures and parameterizations')
+    p.add_argument('-lib',type=str,default=None,help='local user library of molecular structures and parameterizations (default: ./lib if it exists, otherwise none)')
     p.add_argument('-ocfg',type=str,default='',help='original htpolynet config file used to generate project(s)')
     p.add_argument('-cfg',type=str,default='',help='config file specifying the operations to perform')
     p.add_argument('--no-banner',default=False,action='store_true',help='suppress the startup banner')

{htpolynet-2.3.0 → htpolynet-2.3.1}/src/htpolynet/core/projectfilesystem.py

@@ -208,7 +208,9 @@ class UserLibrary:
             pathname (str): path to the user library directory, defaults to '.'
         """
         self.root = Path(os.path.abspath(pathname))
-        assert self.root.exists() and self.root.is_dir(), f'{pathname} is not a directory'
+        assert self.root.exists() and self.root.is_dir(), (
+            f'user library {pathname!r} (resolved to {self.root}) is not a directory; '
+            f'pass -lib <path> to point at an existing library, or create it')
 
     def exists(self, filename):
         """Checks if filename exists in the user library.
@@ -448,6 +450,28 @@ def pfs_setup(root='.', topdirs=['molecules', 'systems', 'plots'], projdir='next
                                userlibrary=userlibrary, mock=mock)
 
 
+def resolve_user_library(pathname, default='lib'):
+    """Returns the user-library path a subcommand should use, or None for none.
+
+    An explicitly supplied path is returned unchanged, so that a typo fails
+    loudly in UserLibrary rather than silently degrading to no library.  When
+    nothing was supplied, the conventional ``lib/`` is used only if it is
+    actually there: a subcommand that merely reads finished results has no
+    reason to require a molecule library, and demanding one turns the default
+    value of a flag the user never typed into a hard error.
+
+    Args:
+        pathname (str or None): the value of the ``-lib`` flag, or None if unset
+        default (str): the conventional library directory, defaults to 'lib'
+
+    Returns:
+        str or None: path to use as the user library, or None for no user library
+    """
+    if pathname is not None:
+        return pathname
+    return default if os.path.isdir(default) else None
+
+
 def checkout(filename, altpath=[]):
     """Copies a file to cwd; searches user library, then user cache, then system library.
 

{htpolynet-2.3.0 → htpolynet-2.3.1}/src/htpolynet/core/runtime.py

@@ -619,18 +619,27 @@ class Runtime:
         of the stage is what someone scanning the tail of a log actually hits,
         and it arrives while the expensive part of the build is still ahead of
         them rather than behind.
+
+        Both messages have to say that the cached parameters are being *used*,
+        not merely that they could not be checked.  A reader who upgrades with
+        an existing library, asks for one charge method, and gets another one's
+        numbers will otherwise conclude the cache guard does not work -- the
+        correct behavior here is indistinguishable from the bug it replaced
+        unless the message says which is happening.
         """
         if not self.unverified_parameterizations:
             return
         names = sorted(set(self.unverified_parameterizations))
         ess = '' if len(names) == 1 else 's'
         requested = paramcache.build_key(self.cfg.ambertools)
-        my_logger(f'{len(names)} parameterization{ess} of unverified provenance', logger.warning)
-        logger.warning(f'Reused from the library, but the library entry records nothing about how it')
-        logger.warning(f'was built, so this run could not confirm it was parameterized with the')
-        logger.warning(f'requested {requested["charge_method"]!r} charge method:')
+        my_logger(f'{len(names)} parameterization{ess} reused without provenance', logger.warning)
+        logger.warning('These were taken from the library, which records nothing about how they were')
+        logger.warning('built. This build therefore carries whatever charges those entries hold, and')
+        logger.warning(f'they may not be {requested["charge_method"]!r}:')
         my_logger(names, logger.warning)
-        logger.warning('Rebuild them from the current directives with --force-parameterization.')
+        logger.warning('This is expected for entries written before htpolynet 2.3, and is not a')
+        logger.warning('failure. Rebuild them with --force-parameterization if this build\'s charges')
+        logger.warning('need to be certain.')
 
     @staticmethod
     def _checkin_parameterization(mname, overwrite):
@@ -687,9 +696,11 @@ class Runtime:
             pfs.checkout(keyfile)
         stored = paramcache.read_key(M.name)
         if stored is None:
-            logger.warning(f'Cached parameterization for {M.name} carries no record of how it was built, '
-                           f'so it cannot be checked against the requested {requested["charge_method"]!r} '
-                           f'charge method; use --force-parameterization to rebuild it')
+            logger.warning(f'Reusing cached parameterization for {M.name}, which carries no record of '
+                           f'how it was built: this build takes whatever charges that entry holds, and '
+                           f'they may not be {requested["charge_method"]!r}. Expected for an entry '
+                           f'written before htpolynet 2.3; rebuild it with --force-parameterization '
+                           f'if this build\'s charges need to be certain.')
             self.unverified_parameterizations.append(M.name)
             return []
         diffs = paramcache.describe_mismatch(stored, requested)

{htpolynet-2.3.0 → htpolynet-2.3.1}/src/htpolynet/external/software.py

@@ -90,8 +90,15 @@ def _mdrun_cmd(base):
 
 def _get_git_commit():
     """Records the short git commit hash of the htpolynet source tree and
-    whether there are uncommitted changes.  Falls back to 'unknown' if the
-    working directory is not inside a git repo or git is not available.
+    whether there are uncommitted changes.
+
+    An installed copy -- pip, conda, or the published container -- has no
+    ``.git`` beside it, so the git lookup fails and there is nothing to
+    report.  Reporting 'unknown' there leaves a build with no way to answer
+    "what code produced this" from inside itself, which is exactly the
+    question the parameterization records exist to answer for molecules.
+    Fall back to the installed distribution version, which for a released
+    install maps to a tag and is the honest answer.
     """
     global git_commit
     src = os.path.dirname(__file__)
@@ -108,6 +115,15 @@ def _get_git_commit():
             )
             if dirty.returncode == 0 and dirty.stdout.strip():
                 git_commit += ' (uncommitted changes present)'
+            return
+    except Exception:
+        pass
+    try:
+        from importlib.metadata import version, PackageNotFoundError
+        try:
+            git_commit = f'not a git checkout (installed version {version("htpolynet")})'
+        except PackageNotFoundError:
+            pass
     except Exception:
         pass
 

{htpolynet-2.3.0 → htpolynet-2.3.1}/tests/unit/test_paramcache.py

@@ -181,6 +181,11 @@ class TestCachedParameterizationMismatch:
         assert diffs == []
         assert 'TAZ' in caplog.text
         assert 'force-parameterization' in caplog.text
+        # The message must say the cached values are being USED, not merely
+        # that they could not be checked: correct behavior here is otherwise
+        # indistinguishable from the bug it replaced.
+        assert 'Reusing cached parameterization' in caplog.text
+        assert 'may not be' in caplog.text
         assert runtime.unverified_parameterizations == ['TAZ'], \
             'an unverifiable entry must also reach the stage-end summary'
 
@@ -212,7 +217,7 @@ class TestCachedParameterizationMismatch:
         paramcache.write_key('TAZ', paramcache.build_key({'charge_method': 'bcc'}))
         with caplog.at_level('WARNING'):
             assert _mismatch('TAZ', charge_method='bcc') == []
-        assert 'no record of how it was built' in caplog.text
+        assert 'carries no record of how it was built' in caplog.text
 
 
 class TestCheckinParameterization:
@@ -311,16 +316,27 @@ class TestUnverifiedSummary:
 
     def test_states_the_count_and_the_requested_charge_method(self, caplog):
         text = self._report(['TAZ', 'BAF'], caplog, charge_method='bcc')
-        assert '2 parameterizations of unverified provenance' in text
+        assert '2 parameterizations reused without provenance' in text
         assert "'bcc'" in text
 
     def test_singular_for_one_molecule(self, caplog):
         text = self._report(['TAZ'], caplog, charge_method='bcc')
-        assert '1 parameterization of unverified provenance' in text
+        assert '1 parameterization reused without provenance' in text
+
+    def test_says_the_build_carries_the_cached_charges(self, caplog):
+        # Without this, a reader who upgrades with an existing library, asks
+        # for bcc and gets gas numbers concludes the guard is broken.
+        text = self._report(['TAZ'], caplog, charge_method='bcc')
+        assert 'carries whatever charges those entries hold' in text
+        assert 'may not be' in text
+
+    def test_says_this_is_expected_rather_than_a_failure(self, caplog):
+        text = self._report(['TAZ'], caplog, charge_method='bcc')
+        assert 'is not a' in text and 'failure' in text
 
     def test_says_how_to_resolve_it(self, caplog):
         assert 'force-parameterization' in self._report(['TAZ'], caplog, charge_method='bcc')
 
     def test_a_molecule_reported_twice_is_listed_once(self, caplog):
         text = self._report(['TAZ', 'TAZ'], caplog, charge_method='bcc')
-        assert '1 parameterization of unverified provenance' in text
+        assert '1 parameterization reused without provenance' in text

{htpolynet-2.3.0 → htpolynet-2.3.1}/tests/unit/test_projectfilesystem.py

@@ -476,3 +476,54 @@ class TestDirsIntegration(unittest.TestCase):
         proj_path = os.path.join(self.base, 'p')
         for d in Dirs.analyze_topdirs:
             self.assertTrue(os.path.isdir(os.path.join(proj_path, d)))
+
+
+class TestResolveUserLibrary(unittest.TestCase):
+    """`htpolynet postsim` used to die in any directory without a `lib/`.
+
+    `-lib` defaulted to the string 'lib' for postsim and analyze, but only
+    `run` creates that tree, so the default value of a flag the user never
+    typed reached UserLibrary and tripped its existence assertion.  The
+    documented container invocation -- postsim against a staged directory
+    holding only finished results -- failed in three seconds.
+    """
+
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        self.orig = os.getcwd()
+        os.chdir(self.tmpdir)
+
+    def tearDown(self):
+        os.chdir(self.orig)
+        shutil.rmtree(self.tmpdir, ignore_errors=True)
+
+    def test_absent_default_resolves_to_no_library(self):
+        self.assertIsNone(pfs.resolve_user_library(None))
+
+    def test_present_default_is_used(self):
+        os.makedirs('lib')
+        self.assertEqual(pfs.resolve_user_library(None), 'lib')
+
+    def test_explicit_path_is_returned_even_when_missing(self):
+        # A typo'd -lib must fail loudly in UserLibrary rather than silently
+        # degrade to no library.
+        self.assertEqual(pfs.resolve_user_library('mylib'), 'mylib')
+
+    def test_explicit_path_still_reaches_the_existence_check(self):
+        with self.assertRaises(AssertionError):
+            UserLibrary(pfs.resolve_user_library('/this/path/does/not/exist'))
+
+    def test_resolved_absent_default_never_reaches_the_check(self):
+        # The regression itself: with no lib/ present and no -lib given,
+        # nothing is constructed, so nothing can assert.
+        resolved = pfs.resolve_user_library(None)
+        self.assertIsNone(resolved)
+        pfs_obj = ProjectFileSystem(root=self.tmpdir, userlibrary=resolved, mock=True)
+        self.assertIsNone(pfs_obj.userlibrary)
+
+    def test_error_message_names_the_flag_and_the_remedy(self):
+        with self.assertRaises(AssertionError) as cm:
+            UserLibrary('/this/path/does/not/exist')
+        msg = str(cm.exception)
+        self.assertIn('-lib', msg)
+        self.assertIn('/this/path/does/not/exist', msg)

htpolynet-2.3.1/tests/unit/test_software_provenance.py

@@ -0,0 +1,61 @@
+"""Tests what an htpolynet build can say about the code that produced it.
+
+`htpolynet info` reports a git commit, which works from a source checkout and
+does not exist for an installed copy -- pip, conda, or the published
+container, none of which carry a `.git`.  Reporting 'unknown' there leaves a
+build unable to answer "what code produced this" from inside itself, which is
+the same question the parameterization records answer for molecules.
+
+Author: Cameron F. Abrams <cfa22@drexel.edu>
+"""
+import subprocess
+
+import pytest
+
+import htpolynet.external.software as software
+
+
+@pytest.fixture(autouse=True)
+def restore_git_commit():
+    """software.git_commit is module state; put it back afterwards."""
+    original = software.git_commit
+    yield
+    software.git_commit = original
+
+
+def _no_git(monkeypatch):
+    """Makes the git lookup fail the way it does outside a checkout."""
+    def boom(*a, **kw):
+        raise FileNotFoundError('git')
+    monkeypatch.setattr(subprocess, 'run', boom)
+
+
+class TestGitCommitReporting:
+
+    def test_a_checkout_reports_a_commit(self):
+        software.git_commit = 'unset'
+        software._get_git_commit()
+        # The test suite runs inside the repo, so this is a real lookup.
+        assert software.git_commit != 'unset'
+        assert 'unknown' not in software.git_commit
+
+    def test_an_installed_copy_reports_its_version(self, monkeypatch):
+        _no_git(monkeypatch)
+        software.git_commit = 'unset'
+        software._get_git_commit()
+        assert 'installed version' in software.git_commit
+        assert 'not a git checkout' in software.git_commit
+
+    def test_an_installed_copy_never_reports_unknown(self, monkeypatch):
+        # The container case 8a hit: htpolynet info said 'unknown', so a build
+        # could not identify its own code.
+        _no_git(monkeypatch)
+        software.git_commit = 'unknown'
+        software._get_git_commit()
+        assert software.git_commit != 'unknown'
+
+    def test_the_lookup_never_raises(self, monkeypatch):
+        # Provenance reporting must not be able to abort a build.
+        _no_git(monkeypatch)
+        monkeypatch.setattr(software, '__name__', software.__name__)
+        software._get_git_commit()