CodeEntropy 2.0.0__tar.gz → 2.1.0__tar.gz

{codeentropy-2.0.0 → codeentropy-2.1.0}/.github/workflows/daily.yaml

@@ -35,4 +35,4 @@ jobs:
           python -m pip install -e .[testing]
 
       - name: Pytest (unit) • ${{ matrix.os }} • py${{ matrix.python-version }}
-        run: python -m pytest tests/unit -q
+        run: python -m pytest tests/unit

{codeentropy-2.0.0 → codeentropy-2.1.0}/.github/workflows/pr.yaml

@@ -33,7 +33,7 @@ jobs:
           python -m pip install -e .[testing]
 
       - name: Pytest (unit) • ${{ matrix.os }}, ${{ matrix.python-version }}
-        run: python -m pytest tests/unit -q
+        run: python -m pytest tests/unit
 
   regression-quick:
     name: Regression (quick)
@@ -62,7 +62,7 @@ jobs:
           python -m pip install -e .[testing]
 
       - name: Pytest (regression quick)
-        run: python -m pytest tests/regression -q
+        run: python -m pytest tests/regression
 
       - name: Upload artifacts (failure)
         if: failure()

{codeentropy-2.0.0 → codeentropy-2.1.0}/.github/workflows/release.yaml

@@ -163,30 +163,36 @@ jobs:
           sed -i "s/^{% set version = \".*\" %}$/{% set version = \"${{ github.event.inputs.version }}\" %}/" conda-recipe/meta.yaml
           grep '{% set version' conda-recipe/meta.yaml
 
-      - name: Setup Conda
+      - name: Setup Conda (conda-forge only)
         uses: conda-incubator/setup-miniconda@v3
         with:
           miniforge-variant: Miniforge3
           python-version: "3.12"
-          auto-activate-base: false
+          auto-activate: false
+          conda-remove-defaults: true
+          channels: conda-forge
+          channel-priority: strict
 
       - name: Install build tools
         shell: bash -l {0}
         run: |
           conda install -y conda-build anaconda-client
-          conda config --add channels conda-forge
-          conda config --set channel_priority strict
           conda config --set anaconda_upload no
 
       - name: Build package
         shell: bash -l {0}
+        env:
+          PIP_NO_INDEX: "0"
         run: |
+          PKG_PATH=$(conda build conda-recipe --output)
+          echo "PKG_PATH=$PKG_PATH" >> "$GITHUB_ENV"
           conda build conda-recipe
+          test -f "$PKG_PATH"
+          echo "Built: $PKG_PATH"
 
       - name: Upload to Anaconda
         shell: bash -l {0}
         env:
           ANACONDA_API_TOKEN: ${{ secrets.ANACONDA_TOKEN }}
         run: |
-          PKG_PATH=$(conda build conda-recipe --output)
           anaconda -t "$ANACONDA_API_TOKEN" upload "$PKG_PATH" --user CCPBioSim --force

{codeentropy-2.0.0 → codeentropy-2.1.0}/.github/workflows/weekly-regression.yaml

@@ -13,7 +13,6 @@ jobs:
   regression:
     name: Regression tests (including slow)
     runs-on: ubuntu-24.04
-    timeout-minutes: 180
     steps:
       - name: Checkout repo
         uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6
@@ -36,7 +35,7 @@ jobs:
           pip install -e .[testing]
 
       - name: Run regression test suite
-        run: pytest tests/regression -q --run-slow
+        run: pytest tests/regression --run-slow
 
       - name: Upload regression artifacts on failure
         if: failure()

{codeentropy-2.0.0 → codeentropy-2.1.0}/CITATION.cff

@@ -76,5 +76,5 @@ keywords:
   - biomolecular simulations
   - protein flexibility
 license: MIT
-version: 2.0.0
-date-released: '2026-02-27'
+version: 2.1.0
+date-released: '2026-03-26'

{codeentropy-2.0.0 → codeentropy-2.1.0}/CodeEntropy/__init__.py

@@ -8,4 +8,4 @@ entropy estimates, supporting a wide range of applications in molecular simulati
 and statistical mechanics.
 """
 
-__version__ = "2.0.0"
+__version__ = "2.1.0"

{codeentropy-2.0.0 → codeentropy-2.1.0}/CodeEntropy/config/argparse.py

@@ -25,7 +25,7 @@ import glob
 import logging
 import os
 from dataclasses import dataclass
-from typing import Any, Dict, Optional, Set
+from typing import Any
 
 import yaml
 
@@ -48,11 +48,11 @@ class ArgSpec:
     help: str
     default: Any = None
     type: Any = None
-    action: Optional[str] = None
-    nargs: Optional[str] = None
+    action: str | None = None
+    nargs: str | None = None
 
 
-ARG_SPECS: Dict[str, ArgSpec] = {
+ARG_SPECS: dict[str, ArgSpec] = {
     "top_traj_file": ArgSpec(
         type=str,
         nargs="+",
@@ -145,6 +145,12 @@ ARG_SPECS: Dict[str, ArgSpec] = {
         default=True,
         help="Use bonded axes to rotate forces for UA level vibrational entropies",
     ),
+    "search_type": ArgSpec(
+        type=str,
+        default="RAD",
+        help="Type of neighbor search to use."
+        "Default RAD; grid search is also available",
+    ),
 }
 
 
@@ -159,7 +165,7 @@ class ConfigResolver:
       - validating trajectory-related numeric parameters
     """
 
-    def __init__(self, arg_specs: Optional[Dict[str, ArgSpec]] = None) -> None:
+    def __init__(self, arg_specs: dict[str, ArgSpec] | None = None) -> None:
         """Initialize the manager.
 
         Args:
@@ -168,7 +174,7 @@ class ConfigResolver:
         """
         self._arg_specs = dict(arg_specs or ARG_SPECS)
 
-    def load_config(self, directory_path: str) -> Dict[str, Any]:
+    def load_config(self, directory_path: str) -> dict[str, Any]:
         """Load the first YAML config file found in a directory.
 
         The current behavior matches your existing workflow:
@@ -188,7 +194,7 @@ class ConfigResolver:
 
         config_path = yaml_files[0]
         try:
-            with open(config_path, "r", encoding="utf-8") as file:
+            with open(config_path, encoding="utf-8") as file:
                 config = yaml.safe_load(file) or {"run1": {}}
             logger.info("Loaded configuration from: %s", config_path)
             return config
@@ -253,7 +259,7 @@ class ConfigResolver:
                 )
                 continue
 
-            kwargs: Dict[str, Any] = {}
+            kwargs: dict[str, Any] = {}
             if spec.type is not None:
                 kwargs["type"] = spec.type
             if spec.default is not None:
@@ -266,7 +272,7 @@ class ConfigResolver:
         return parser
 
     def resolve(
-        self, args: argparse.Namespace, run_config: Optional[Dict[str, Any]]
+        self, args: argparse.Namespace, run_config: dict[str, Any] | None
     ) -> argparse.Namespace:
         """Merge CLI arguments with YAML configuration and adjust logging level.
 
@@ -306,8 +312,8 @@ class ConfigResolver:
 
     @staticmethod
     def _detect_cli_overrides(
-        args_dict: Dict[str, Any], default_dict: Dict[str, Any]
-    ) -> Set[str]:
+        args_dict: dict[str, Any], default_dict: dict[str, Any]
+    ) -> set[str]:
         """Detect which args were explicitly overridden in the CLI.
 
         Args:
@@ -322,8 +328,8 @@ class ConfigResolver:
     def _apply_yaml_defaults(
         self,
         args: argparse.Namespace,
-        run_config: Dict[str, Any],
-        cli_provided: Set[str],
+        run_config: dict[str, Any],
+        cli_provided: set[str],
     ) -> None:
         """Apply YAML values onto args for keys not provided by CLI.
 
@@ -336,7 +342,7 @@ class ConfigResolver:
             if yaml_value is None or key in cli_provided:
                 continue
             if key in self._arg_specs:
-                logger.debug("Using YAML value for %s: %s", key, yaml_value)
+                logger.debug(f"Using YAML value for {key}: {yaml_value}")
                 setattr(args, key, yaml_value)
 
     def _ensure_defaults(self, args: argparse.Namespace) -> None:

{codeentropy-2.0.0 → codeentropy-2.1.0}/CodeEntropy/config/runtime.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 import logging
 import os
 import pickle
-from typing import Any, Dict, Optional
+from typing import Any
 
 import MDAnalysis as mda
 import requests
@@ -112,7 +112,7 @@ class CodeEntropyRunner:
 
         return new_folder_path
 
-    def load_citation_data(self) -> Optional[Dict[str, Any]]:
+    def load_citation_data(self) -> dict[str, Any] | None:
         """Load CITATION.cff from GitHub.
 
         If the request fails (offline, blocked, etc.), returns None.
@@ -335,7 +335,7 @@ class CodeEntropyRunner:
         kcal_units = args.kcal_force_units
 
         if forcefile is None:
-            logger.debug("Loading Universe with %s and %s", tprfile, trrfile)
+            logger.debug(f"Loading Universe with {tprfile} and {trrfile}")
             return mda.Universe(tprfile, trrfile, format=fileformat)
 
         return universe_operations.merge_forces(

{codeentropy-2.0.0 → codeentropy-2.1.0}/CodeEntropy/core/logging.py

@@ -16,7 +16,6 @@ from __future__ import annotations
 
 import logging
 import os
-from typing import Dict, Optional
 
 from rich.console import Console
 from rich.logging import RichHandler
@@ -55,7 +54,7 @@ class LoggingConfig:
         handlers: Mapping of handler name to handler instance.
     """
 
-    _console: Optional[Console] = None
+    _console: Console | None = None
 
     @classmethod
     def get_console(cls) -> Console:
@@ -80,7 +79,7 @@ class LoggingConfig:
 
         self.level = level
         self.console = self.get_console()
-        self.handlers: Dict[str, logging.Handler] = {}
+        self.handlers: dict[str, logging.Handler] = {}
 
         self._setup_handlers()
 

codeentropy-2.1.0/CodeEntropy/entropy/configurational.py

@@ -0,0 +1,86 @@
+"""Conformational entropy utilities.
+
+This module provides:
+
+- Assignment of discrete conformational states for a single dihedral time series.
+- Computation of conformational entropy from a sequence of state labels.
+
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+class ConformationalEntropy:
+    """Compute conformational entropy from states information."""
+
+    _GAS_CONST: float = 8.3144598484848
+
+    def __init__(self) -> None:
+        """Math-only engine.
+
+        This class assigns conformational states and computes conformational entropy.
+        It does not depend on the workflow runner, universe, grouping, or reporting.
+        """
+        pass
+
+    def conformational_entropy_calculation(self, states: Any) -> float:
+        """Compute conformational entropy for a sequence of state labels.
+
+        Entropy is computed as:
+
+            S = -R * sum_i p_i * ln(p_i)
+
+        where p_i is the observed probability of state i in ``states``.
+
+        Args:
+            states: Sequence/array of discrete state labels. Empty/None yields 0.0.
+            number_frames: Frame count metadata.
+
+        Returns:
+            float: Conformational entropy in J/mol/K.
+        """
+        arr = self._to_1d_array(states)
+        if arr is None or arr.size == 0:
+            return 0.0
+
+        values, counts = np.unique(arr, return_counts=True)
+        total_count = int(np.sum(counts))
+        if total_count <= 0 or values.size <= 1:
+            return 0.0
+
+        probs = counts.astype(float) / float(total_count)
+        probs = probs[probs > 0.0]
+
+        s_conf = -self._GAS_CONST * float(np.sum(probs * np.log(probs)))
+        logger.debug(f"Total conformational entropy: {s_conf}")
+        return s_conf
+
+    @staticmethod
+    def _to_1d_array(states: Any) -> np.ndarray | None:
+        """Convert a state sequence into a 1D numpy array.
+
+        Args:
+            states: Input sequence/array.
+
+        Returns:
+            1D numpy array, or None if input is not usable.
+        """
+        if states is None:
+            return None
+
+        if isinstance(states, np.ndarray):
+            arr = states.reshape(-1)
+        else:
+            try:
+                arr = np.asarray(list(states)).reshape(-1)
+            except TypeError:
+                return None
+
+        return arr

{codeentropy-2.0.0 → codeentropy-2.1.0}/CodeEntropy/entropy/graph.py

@@ -15,18 +15,19 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass
-from typing import Any, Dict
+from typing import Any
 
 import networkx as nx
 
 from CodeEntropy.entropy.nodes.aggregate import AggregateEntropyNode
 from CodeEntropy.entropy.nodes.configurational import ConfigurationalEntropyNode
+from CodeEntropy.entropy.nodes.orientational import OrientationalEntropyNode
 from CodeEntropy.entropy.nodes.vibrational import VibrationalEntropyNode
 
 logger = logging.getLogger(__name__)
 
 
-SharedData = Dict[str, Any]
+SharedData = dict[str, Any]
 
 
 @dataclass(frozen=True)
@@ -57,9 +58,9 @@ class EntropyGraph:
     def __init__(self) -> None:
         """Initialize an empty entropy graph."""
         self._graph: nx.DiGraph = nx.DiGraph()
-        self._nodes: Dict[str, Any] = {}
+        self._nodes: dict[str, Any] = {}
 
-    def build(self) -> "EntropyGraph":
+    def build(self) -> EntropyGraph:
         """Populate the graph with the standard entropy workflow.
 
         Returns:
@@ -68,10 +69,15 @@ class EntropyGraph:
         specs = (
             NodeSpec("vibrational_entropy", VibrationalEntropyNode()),
             NodeSpec("configurational_entropy", ConfigurationalEntropyNode()),
+            NodeSpec("orientational_entropy", OrientationalEntropyNode()),
             NodeSpec(
                 "aggregate_entropy",
                 AggregateEntropyNode(),
-                deps=("vibrational_entropy", "configurational_entropy"),
+                deps=(
+                    "vibrational_entropy",
+                    "configurational_entropy",
+                    "orientational_entropy",
+                ),
             ),
         )
 
@@ -82,7 +88,7 @@ class EntropyGraph:
 
     def execute(
         self, shared_data: SharedData, *, progress: object | None = None
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Execute the entropy graph in topological order.
 
         Nodes are executed in dependency order (topological sort). Each node reads
@@ -105,7 +111,7 @@ class EntropyGraph:
         Raises:
             KeyError: If a node name is missing from the internal node registry.
         """
-        results: Dict[str, Any] = {}
+        results: dict[str, Any] = {}
 
         for node_name in nx.topological_sort(self._graph):
             node = self._nodes[node_name]

{codeentropy-2.0.0 → codeentropy-2.1.0}/CodeEntropy/entropy/nodes/aggregate.py

@@ -2,10 +2,11 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping, MutableMapping
 from dataclasses import dataclass
-from typing import Any, Dict, Mapping, MutableMapping, Optional
+from typing import Any
 
-EntropyResults = Dict[str, Any]
+EntropyResults = dict[str, Any]
 
 
 @dataclass(frozen=True, slots=True)
@@ -25,11 +26,12 @@ class AggregateEntropyNode:
 
     vibrational_key: str = "vibrational_entropy"
     configurational_key: str = "configurational_entropy"
+    orientational_key: str = "orientational_entropy"
     output_key: str = "entropy_results"
 
     def run(
         self, shared_data: MutableMapping[str, Any], **_: Any
-    ) -> Dict[str, EntropyResults]:
+    ) -> dict[str, EntropyResults]:
         """Run the aggregation step.
 
         Args:
@@ -69,10 +71,13 @@ class AggregateEntropyNode:
             "configurational_entropy": self._get_optional(
                 shared_data, self.configurational_key
             ),
+            "orientational_entropy": self._get_optional(
+                shared_data, self.orientational_key
+            ),
         }
 
     @staticmethod
-    def _get_optional(shared_data: Mapping[str, Any], key: str) -> Optional[Any]:
+    def _get_optional(shared_data: Mapping[str, Any], key: str) -> Any | None:
         """Fetch an optional value from shared data.
 
         Args:

{codeentropy-2.0.0 → codeentropy-2.1.0}/CodeEntropy/entropy/nodes/configurational.py

@@ -3,16 +3,9 @@
 from __future__ import annotations
 
 import logging
+from collections.abc import Iterable, Mapping, MutableMapping, Sequence
 from typing import (
     Any,
-    Dict,
-    Iterable,
-    Mapping,
-    MutableMapping,
-    Optional,
-    Sequence,
-    Tuple,
-    Union,
 )
 
 import numpy as np
@@ -23,8 +16,8 @@ logger = logging.getLogger(__name__)
 
 GroupId = int
 ResidueId = int
-StateKey = Tuple[GroupId, ResidueId]
-StateSequence = Union[Sequence[Any], np.ndarray]
+StateKey = tuple[GroupId, ResidueId]
+StateSequence = Sequence[Any] | np.ndarray
 
 
 class ConfigurationalEntropyNode:
@@ -36,7 +29,7 @@ class ConfigurationalEntropyNode:
     Results are written back into ``shared_data["configurational_entropy"]``.
     """
 
-    def run(self, shared_data: MutableMapping[str, Any], **_: Any) -> Dict[str, Any]:
+    def run(self, shared_data: MutableMapping[str, Any], **_: Any) -> dict[str, Any]:
         """Execute configurational entropy calculation.
 
         Args:
@@ -58,7 +51,7 @@ class ConfigurationalEntropyNode:
         ce = self._build_entropy_engine()
 
         fragments = universe.atoms.fragments
-        results: Dict[int, Dict[str, float]] = {}
+        results: dict[int, dict[str, float]] = {}
 
         for group_id, mol_ids in groups.items():
             results[group_id] = {"ua": 0.0, "res": 0.0, "poly": 0.0}
@@ -104,9 +97,9 @@ class ConfigurationalEntropyNode:
 
     def _get_state_containers(
         self, shared_data: Mapping[str, Any]
-    ) -> Tuple[
-        Dict[StateKey, StateSequence],
-        Union[Dict[GroupId, StateSequence], Sequence[Optional[StateSequence]]],
+    ) -> tuple[
+        dict[StateKey, StateSequence],
+        dict[GroupId, StateSequence] | Sequence[StateSequence | None],
     ]:
         """Retrieve conformational state containers.
 
@@ -144,7 +137,7 @@ class ConfigurationalEntropyNode:
         residues: Iterable[Any],
         states_ua: Mapping[StateKey, StateSequence],
         n_frames: int,
-        reporter: Optional[Any],
+        reporter: Any | None,
     ) -> float:
         """Compute united atom entropy for a group.
 
@@ -163,7 +156,7 @@ class ConfigurationalEntropyNode:
 
         for res_id, res in enumerate(residues):
             states = states_ua.get((group_id, res_id))
-            val = self._entropy_or_zero(ce, states, n_frames)
+            val = self._entropy_or_zero(ce, states)
             total += val
 
             if reporter is not None:
@@ -186,29 +179,28 @@ class ConfigurationalEntropyNode:
         *,
         ce: ConformationalEntropy,
         group_id: int,
-        states_res: Union[Dict[int, StateSequence], Sequence[Optional[StateSequence]]],
+        states_res: dict[int, StateSequence] | Sequence[StateSequence | None],
         n_frames: int,
     ) -> float:
         """Compute residue-level entropy for a group."""
         group_states = self._get_group_states(states_res, group_id)
-        return self._entropy_or_zero(ce, group_states, n_frames)
+        return self._entropy_or_zero(ce, group_states)
 
     def _entropy_or_zero(
         self,
         ce: ConformationalEntropy,
-        states: Optional[StateSequence],
-        n_frames: int,
+        states: StateSequence | None,
     ) -> float:
         """Return entropy value or zero if no state data exists."""
         if not self._has_state_data(states):
             return 0.0
-        return float(ce.conformational_entropy_calculation(states, n_frames))
+        return float(ce.conformational_entropy_calculation(states))
 
     @staticmethod
     def _get_group_states(
-        states_res: Union[Dict[int, StateSequence], Sequence[Optional[StateSequence]]],
+        states_res: dict[int, StateSequence] | Sequence[StateSequence | None],
         group_id: int,
-    ) -> Optional[StateSequence]:
+    ) -> StateSequence | None:
         """Fetch group states from container."""
         if isinstance(states_res, dict):
             return states_res.get(group_id)
@@ -217,7 +209,7 @@ class ConfigurationalEntropyNode:
         return None
 
     @staticmethod
-    def _has_state_data(states: Optional[StateSequence]) -> bool:
+    def _has_state_data(states: StateSequence | None) -> bool:
         """Check if state container has usable data."""
         if states is None:
             return False

codeentropy-2.1.0/CodeEntropy/entropy/nodes/orientational.py

@@ -0,0 +1,84 @@
+"""Node for computing orientational entropy from neighbors."""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import MutableMapping, Sequence
+from typing import (
+    Any,
+)
+
+import numpy as np
+
+from CodeEntropy.entropy.orientational import OrientationalEntropy
+
+logger = logging.getLogger(__name__)
+
+GroupId = int
+ResidueId = int
+StateKey = tuple[GroupId, ResidueId]
+StateSequence = Sequence[Any] | np.ndarray
+
+
+class OrientationalEntropyNode:
+    """Compute orientational entropy using precomputed neighbors and symmetry.
+
+    This node reads number of neighbors and symmetry from ``shared_data`` and
+    computes entropy contributions at the molecular (highest) level.
+
+    Results are written back into ``shared_data["orientational_entropy"]``.
+    """
+
+    def run(self, shared_data: MutableMapping[str, Any], **_: Any) -> dict[str, Any]:
+        """Execute orientational entropy calculation.
+
+        Args:
+            shared_data: Shared workflow state dictionary.
+
+        Returns:
+            Dictionary containing orientational entropy results.
+
+        Raises:
+            KeyError: If required keys are missing.
+        """
+        groups = shared_data["groups"]
+        levels = shared_data["levels"]
+        neighbors = shared_data["neighbors"]
+        symmetry_number = shared_data["symmetry_number"]
+        linear = shared_data["linear"]
+        reporter = shared_data.get("reporter")
+
+        oe = self._build_entropy_engine()
+
+        results: dict[int, float] = {}
+
+        for group_id, mol_ids in groups.items():
+            results[group_id] = 0
+            if not mol_ids:
+                continue
+            rep_mol_id = mol_ids[0]
+            highest_level = levels[rep_mol_id][-1]
+
+            neighbor = neighbors[group_id]
+            symmetry = symmetry_number[group_id]
+            line = linear[group_id]
+
+            result_value = oe.calculate(
+                neighbor,
+                symmetry,
+                line,
+            )
+            results[group_id] = result_value
+
+            if reporter is not None:
+                reporter.add_results_data(
+                    group_id, highest_level, "Orientational", result_value
+                )
+
+        shared_data["orientational_entropy"] = results
+
+        return {"orientational_entropy": results}
+
+    def _build_entropy_engine(self) -> OrientationalEntropy:
+        """Create the entropy calculation engine."""
+        return OrientationalEntropy()