ruff formatting part 2 - everything but the tests

openfe/setup/__init__.py

@@ -2,13 +2,17 @@
 # For details, see https://github.com/OpenFreeEnergy/openfe
 
 
-from .atom_mapping import (LigandAtomMapping,
-                           LigandAtomMapper,
-                           LomapAtomMapper, lomap_scorers,
-                           PersesAtomMapper, perses_scorers,
-                           KartografAtomMapper,)
+from .atom_mapping import (
+    LigandAtomMapping,
+    LigandAtomMapper,
+    LomapAtomMapper,
+    lomap_scorers,
+    PersesAtomMapper,
+    perses_scorers,
+    KartografAtomMapper,
+)
 
 from gufe import LigandNetwork
 from . import ligand_network_planning
 
-from .alchemical_network_planner import RHFEAlchemicalNetworkPlanner, RBFEAlchemicalNetworkPlanner
+from .alchemical_network_planner import RHFEAlchemicalNetworkPlanner, RBFEAlchemicalNetworkPlanner

openfe/setup/alchemical_network_planner/relative_alchemical_network_planner.py

@@ -12,7 +12,9 @@
     ChemicalSystem,
 )
 from gufe import (
-    SmallMoleculeComponent, ProteinComponent, SolventComponent,
+    SmallMoleculeComponent,
+    ProteinComponent,
+    SolventComponent,
     LigandNetwork,
 )
 from openff.units import unit
@@ -41,16 +43,14 @@
 }
 
 
-class RelativeAlchemicalNetworkPlanner(
-    AbstractAlchemicalNetworkPlanner, abc.ABC
-):
+class RelativeAlchemicalNetworkPlanner(AbstractAlchemicalNetworkPlanner, abc.ABC):
     _chemical_system_generator: AbstractChemicalSystemGenerator
 
     def __init__(
         self,
         name: str = "easy_rfe_calculation",  # TODO: remove 'easy'
         mappers: Optional[Iterable[LigandAtomMapper]] = None,
-        mapping_scorer: Callable[[LigandAtomMapping], float]  = default_lomap_score,
+        mapping_scorer: Callable[[LigandAtomMapping], float] = default_lomap_score,
         ligand_network_planner: Callable = generate_minimal_spanning_network,
         protocol: Optional[Protocol] = None,
     ):
@@ -72,27 +72,29 @@ def __init__(
             FE graph, by default RelativeHybridTopologyProtocol( RelativeHybridTopologyProtocol._default_settings() )
         """
         if protocol is None:
-            protocol = RelativeHybridTopologyProtocol(RelativeHybridTopologyProtocol.default_settings())
+            protocol = RelativeHybridTopologyProtocol(
+                RelativeHybridTopologyProtocol.default_settings()
+            )
         if mappers is None:
-            mappers = [LomapAtomMapper(time=20,
-                                       threed=True,
-                                       max3d=1.0,
-                                       element_change=True,
-                                       shift=False,
-                                       )]
+            mappers = [
+                LomapAtomMapper(
+                    time=20,
+                    threed=True,
+                    max3d=1.0,
+                    element_change=True,
+                    shift=False,
+                )
+            ]
 
         self.name = name
         self._mappers = mappers
         self._mapping_scorer = mapping_scorer
         self._ligand_network_planner = ligand_network_planner
         self._protocol = protocol
-        self._chemical_system_generator_type = PROTOCOL_GENERATOR[
-            protocol.__class__
-        ]
+        self._chemical_system_generator_type = PROTOCOL_GENERATOR[protocol.__class__]
 
     @abc.abstractmethod
-    def __call__(self, *args, **kwargs) -> AlchemicalNetwork:
-        ...  # -no-cov-
+    def __call__(self, *args, **kwargs) -> AlchemicalNetwork: ...  # -no-cov-
 
     @property
     def mappers(self) -> Iterable[LigandAtomMapper]:
@@ -116,9 +118,7 @@ def chemical_system_generator_type(
     ) -> Type[AbstractChemicalSystemGenerator]:
         return self._chemical_system_generator_type
 
-    def _construct_ligand_network(
-        self, ligands: Iterable[SmallMoleculeComponent]
-    ) -> LigandNetwork:
+    def _construct_ligand_network(self, ligands: Iterable[SmallMoleculeComponent]) -> LigandNetwork:
         ligand_network = self._ligand_network_planner(
             ligands=ligands, mappers=self.mappers, scorer=self.mapping_scorer
         )
@@ -166,13 +166,9 @@ def _build_transformations(
                 end_state_nodes.extend([stateA_env, stateB_env])
 
         # Todo: make the code here more stable in future: Name doubling check
-        all_transformation_labels = list(
-            map(lambda x: x.name, transformation_edges)
-        )
+        all_transformation_labels = list(map(lambda x: x.name, transformation_edges))
 
-        if len(all_transformation_labels) != len(
-            set(all_transformation_labels)
-        ):
+        if len(all_transformation_labels) != len(set(all_transformation_labels)):
             raise ValueError(
                 "There were multiple transformations with the same edge label! This might lead to overwriting your files. \n labels: "
                 + str(len(all_transformation_labels))
@@ -215,9 +211,7 @@ def _build_transformation(
         if "vacuum" in transformation_name:
             protocol_settings.forcefield_settings.nonbonded_method = "nocutoff"
 
-        transformation_protocol = transformation_protocol.__class__(
-            settings=protocol_settings
-        )
+        transformation_protocol = transformation_protocol.__class__(settings=protocol_settings)
 
         return Transformation(
             stateA=stateA,
@@ -241,7 +235,7 @@ def __init__(
         self,
         name: str = "rhfe",
         mappers: Optional[Iterable[LigandAtomMapper]] = None,
-        mapping_scorer: Callable[[LigandAtomMapping], float]  = default_lomap_score,
+        mapping_scorer: Callable[[LigandAtomMapping], float] = default_lomap_score,
         ligand_network_planner: Callable = generate_minimal_spanning_network,
         protocol: Optional[Protocol] = None,
     ):
@@ -278,7 +272,8 @@ def __call__(
 
         # Prepare system generation
         self._chemical_system_generator = self._chemical_system_generator_type(
-            solvent=solvent, do_vacuum=True,
+            solvent=solvent,
+            do_vacuum=True,
         )
 
         # Build transformations
@@ -299,11 +294,12 @@ class RBFEAlchemicalNetworkPlanner(RelativeAlchemicalNetworkPlanner):
     network planning scheme, then call it on a collection of ligands, protein,
     solvent, and co-factors to create the network.
     """
+
     def __init__(
         self,
         name: str = "rbfe",
         mappers: Optional[Iterable[LigandAtomMapper]] = None,
-        mapping_scorer: Callable[[LigandAtomMapping], float]  = default_lomap_score,
+        mapping_scorer: Callable[[LigandAtomMapping], float] = default_lomap_score,
         ligand_network_planner: Callable = generate_minimal_spanning_network,
         protocol: Optional[Protocol] = None,
     ):
@@ -332,15 +328,16 @@ def _build_transformation(
         if isinstance(transformation_protocol, RelativeHybridTopologyProtocol):
             # adaptive transformation settings are only supported for RelativeHybridTopologyProtocol currently
             protocol_settings = transformation_protocol._adaptive_settings(
-                stateA=stateA, stateB=stateB, mapping=ligand_mapping_edge, initial_settings=protocol_settings
+                stateA=stateA,
+                stateB=stateB,
+                mapping=ligand_mapping_edge,
+                initial_settings=protocol_settings,
             )
 
         if "vacuum" in transformation_name:
             protocol_settings.nonbonded_method = "nocutoff"
 
-        transformation_protocol = transformation_protocol.__class__(
-            settings=protocol_settings
-        )
+        transformation_protocol = transformation_protocol.__class__(settings=protocol_settings)
 
         return Transformation(
             stateA=stateA,
@@ -350,7 +347,6 @@ def _build_transformation(
             protocol=transformation_protocol,
         )
 
-
     def __call__(
         self,
         ligands: Iterable[SmallMoleculeComponent],
@@ -382,7 +378,9 @@ def __call__(
 
         # Prepare system generation
         self._chemical_system_generator = self._chemical_system_generator_type(
-            solvent=solvent, protein=protein, cofactors=cofactors,
+            solvent=solvent,
+            protein=protein,
+            cofactors=cofactors,
         )
 
         # Build transformations

openfe/setup/atom_mapping/ligandatommapper.py

@@ -15,11 +15,13 @@ class LigandAtomMapper(gufe.AtomMapper):
     Subclasses will typically implement the ``_mappings_generator`` method,
     which returns an iterable of :class:`.LigandAtomMapping` suggestions.
     """
+
     @abc.abstractmethod
-    def _mappings_generator(self,
-                            componentA: SmallMoleculeComponent,
-                            componentB: SmallMoleculeComponent
-                            ) -> Iterable[dict[int, int]]:
+    def _mappings_generator(
+        self,
+        componentA: SmallMoleculeComponent,
+        componentB: SmallMoleculeComponent,
+    ) -> Iterable[dict[int, int]]:
         """
         Suggest mapping options for the input molecules.
 
@@ -35,8 +37,10 @@ def _mappings_generator(self,
         """
         ...
 
-    def suggest_mappings(self, componentA: SmallMoleculeComponent,
-                         componentB: SmallMoleculeComponent
+    def suggest_mappings(
+        self,
+        componentA: SmallMoleculeComponent,
+        componentB: SmallMoleculeComponent,
     ) -> Iterable[LigandAtomMapping]:
         """
         Suggest :class:`.LigandAtomMapping` options for the input molecules.

openfe/setup/atom_mapping/lomap_mapper.py

@@ -5,4 +5,5 @@
 The MCS class from Lomap shamelessly wrapped and used here to match our API.
 
 """
+
 from lomap import LomapAtomMapper

openfe/setup/atom_mapping/lomap_scorers.py

@@ -14,4 +14,3 @@
     transmuting_methyl_into_ring_score,
     transmuting_ring_sizes_score,
 )  # looks like we gotta make it detailed for mypy and RTD
-

openfe/setup/atom_mapping/perses_mapper.py

@@ -12,13 +12,12 @@
 from openff.units.openmm import to_openmm
 
 from ...utils.silence_root_logging import silence_root_logging
+
 try:
     with silence_root_logging():
-        from perses.rjmc.atom_mapping import (
-            AtomMapper, InvalidMappingException
-        )
+        from perses.rjmc.atom_mapping import AtomMapper, InvalidMappingException
 except ImportError:
-    pass    # Don't throw  error, will happen later
+    pass  # Don't throw  error, will happen later
 
 from .ligandatommapper import LigandAtomMapper
 
@@ -35,10 +34,8 @@ def _to_dict(self) -> dict:
             "allow_ring_breaking": self.allow_ring_breaking,
             "preserve_chirality": self.preserve_chirality,
             "use_positions": self.use_positions,
-            "coordinate_tolerance": self.coordinate_tolerance.m_as(
-                unit.angstrom
-            ),
-            "_tolerance_unit": "angstrom"
+            "coordinate_tolerance": self.coordinate_tolerance.m_as(unit.angstrom),
+            "_tolerance_unit": "angstrom",
         }
 
     @classmethod
@@ -53,10 +50,13 @@ def _defaults(cls):
         return {}
 
     @requires_package("perses")
-    def __init__(self, allow_ring_breaking: bool = True,
-                 preserve_chirality: bool = True,
-                 use_positions: bool = True,
-                 coordinate_tolerance: Quantity = 0.25 * unit.angstrom):
+    def __init__(
+        self,
+        allow_ring_breaking: bool = True,
+        preserve_chirality: bool = True,
+        use_positions: bool = True,
+        coordinate_tolerance: Quantity = 0.25 * unit.angstrom,
+    ):
         """
         Suggest atom mappings with the Perses atom mapper.
 
@@ -84,12 +84,14 @@ def _mappings_generator(self, componentA, componentB):
         _atom_mapper = AtomMapper(
             use_positions=self.use_positions,
             coordinate_tolerance=to_openmm(self.coordinate_tolerance),
-            allow_ring_breaking=self.allow_ring_breaking)
+            allow_ring_breaking=self.allow_ring_breaking,
+        )
 
         # Try generating a mapping
         try:
             _atom_mappings = _atom_mapper.get_all_mappings(
-                    old_mol=componentA.to_openff(), new_mol=componentB.to_openff())
+                old_mol=componentA.to_openff(), new_mol=componentB.to_openff()
+            )
         except InvalidMappingException:
             return