Adding RDT config and reformatted according to ruff.

Author: rcschrg

.readthedocs.yaml

@@ -0,0 +1,16 @@
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.11"
+
+sphinx:
+  configuration: docs/source/conf.py
+
+python:
+  install:
+    - method: pip
+      path: .
+      extra_requirements:
+        - docs

distributed_resource_optimization/__init__.py

@@ -167,6 +167,7 @@ async def main():
         OptimizationFinishedMessage,
         StartCoordinatedDistributedOptimization,
     )
+
     _MANGO_AVAILABLE = True
 except ImportError:  # pragma: no cover
     pass

distributed_resource_optimization/algorithm/admm/consensus_admm.py

@@ -82,6 +82,7 @@ def primal_residual(self, x: list[np.ndarray], z: list[np.ndarray]) -> float:
 # Factories
 # ---------------------------------------------------------------------------
 
+
 def create_consensus_target_reach_admm_coordinator() -> ADMMGenericCoordinator:
     """Create an :class:`ADMMGenericCoordinator` for the consensus variant."""
     return ADMMGenericCoordinator(global_actor=ADMMConsensusGlobalActor())

distributed_resource_optimization/algorithm/admm/core.py

@@ -30,6 +30,7 @@
 # Message types
 # ---------------------------------------------------------------------------
 
+
 @dataclass
 class ADMMStart:
     """Sent to the coordinator to begin a new ADMM run.
@@ -69,6 +70,7 @@ class ADMMAnswer:
 # Abstract global-actor interface
 # ---------------------------------------------------------------------------
 
+
 class ADMMGlobalActor(ABC):
     """Interface for the coordinator-side global update in ADMM variants."""
 
@@ -136,6 +138,7 @@ def objective(
 # Helper: max-norm over list-of-arrays or single array
 # ---------------------------------------------------------------------------
 
+
 def _max_norm(v: Any) -> float:
     """Return ``max ||v_i||`` if *v* is a list, else ``max |v_j|`` for a vector."""
     if isinstance(v, list):
@@ -160,6 +163,7 @@ def _deepcopy_z(z: Any) -> Any:
 # Generic ADMM coordinator
 # ---------------------------------------------------------------------------
 
+
 class ADMMGenericCoordinator(Coordinator):
     """Standard ADMM iteration loop.
 
@@ -198,9 +202,7 @@ async def start_optimization(
         message_data: ADMMStart,
         meta: Any,
     ) -> list[np.ndarray]:
-        x, _z, _u = await self._run(
-            carrier, message_data.data, message_data.solution_length
-        )
+        x, _z, _u = await self._run(carrier, message_data.data, message_data.solution_length)
         return x
 
     async def _run(
@@ -248,23 +250,16 @@ async def _run(
             # 4. Convergence check
             r_norm = actor.primal_residual(x, z)
             s_norm = rho * _max_diff_norm(z, z_old)
-            eps_pri = (
-                np.sqrt(m * n) * self.abs_tol
-                + self.rel_tol * max(_max_norm(x), _max_norm(z))
-            )
-            eps_dual = (
-                np.sqrt(m * n) * self.abs_tol
-                + self.rel_tol * _max_norm(u)
-            )
+            eps_pri = np.sqrt(m * n) * self.abs_tol + self.rel_tol * max(_max_norm(x), _max_norm(z))
+            eps_dual = np.sqrt(m * n) * self.abs_tol + self.rel_tol * _max_norm(u)
 
             if r_norm < eps_pri and s_norm < eps_dual:
                 logger.debug("ADMM converged in %d iterations.", k)
                 break
 
             if k == self.max_iters:
                 logger.warning(
-                    "ADMM reached max iterations (%d) without full convergence "
-                    "(r=%.4g, s=%.4g).",
+                    "ADMM reached max iterations (%d) without full convergence (r=%.4g, s=%.4g).",
                     self.max_iters,
                     r_norm,
                     s_norm,
@@ -277,6 +272,7 @@ async def _run(
 # Factory
 # ---------------------------------------------------------------------------
 
+
 def create_admm_start(data: Any, length: int | None = None) -> ADMMStart:
     """Create an :class:`ADMMStart` message.
 
@@ -290,6 +286,4 @@ def create_admm_start(data: Any, length: int | None = None) -> ADMMStart:
         return ADMMStart(data=data, solution_length=data.solution_length)
     if hasattr(data, "target"):
         return ADMMStart(data=data, solution_length=len(data.target))
-    raise ValueError(
-        "Cannot infer solution_length; pass it explicitly as the second argument."
-    )
+    raise ValueError("Cannot infer solution_length; pass it explicitly as the second argument.")

distributed_resource_optimization/algorithm/admm/flex_actor.py

@@ -74,9 +74,7 @@ def _local_update(actor: ADMMFlexActor, v: np.ndarray, rho: float) -> np.ndarray
     x_var = cp.Variable(m)
 
     h = rho * np.asarray(v, dtype=float) + np.asarray(actor.S, dtype=float)
-    objective = cp.Minimize(
-        (rho / 2) * cp.sum_squares(x_var) + h @ x_var
-    )
+    objective = cp.Minimize((rho / 2) * cp.sum_squares(x_var) + h @ x_var)
 
     constraints = [
         x_var >= actor.lb,

distributed_resource_optimization/algorithm/admm/sharing_admm.py

@@ -31,6 +31,7 @@
 # Global objective (currently informational only)
 # ---------------------------------------------------------------------------
 
+
 class ADMMTargetDistanceObjective(ADMMGlobalObjective):
     """Quadratic target-distance objective (informational)."""
 
@@ -48,6 +49,7 @@ def objective(
 # Sharing data
 # ---------------------------------------------------------------------------
 
+
 @dataclass
 class ADMMSharingData:
     """Input data for the sharing ADMM variant.
@@ -86,6 +88,7 @@ def create_admm_start(data: ADMMSharingData) -> ADMMStart:
 # Sharing global actor
 # ---------------------------------------------------------------------------
 
+
 class ADMMSharingGlobalActor(ADMMGlobalActor):
     """Global actor for the sharing ADMM variant.
 
@@ -119,16 +122,12 @@ def z_update(
             constraints.append(d_var[i] >= lhs)
             constraints.append(d_var[i] >= -lhs)
 
-        objective = cp.Minimize(
-            (n * rho / 2) * cp.sum_squares(z_var - u - x_avg) + cp.sum(d_var)
-        )
+        objective = cp.Minimize((n * rho / 2) * cp.sum_squares(z_var - u - x_avg) + cp.sum(d_var))
         prob = cp.Problem(objective, constraints)
         prob.solve(solver=cp.OSQP, verbose=False)
 
         if z_var.value is None:
-            raise RuntimeError(
-                f"Sharing ADMM z-update QP did not converge (status={prob.status})."
-            )
+            raise RuntimeError(f"Sharing ADMM z-update QP did not converge (status={prob.status}).")
         return np.asarray(z_var.value, dtype=float)
 
     def u_update(
@@ -167,6 +166,7 @@ def primal_residual(self, x: list[np.ndarray], z: np.ndarray) -> float:
 # Factories
 # ---------------------------------------------------------------------------
 
+
 def create_sharing_target_distance_admm_coordinator() -> ADMMGenericCoordinator:
     """Create an :class:`~.core.ADMMGenericCoordinator` for target-distance sharing."""
     return ADMMGenericCoordinator(

distributed_resource_optimization/algorithm/consensus/averaging.py

@@ -34,6 +34,7 @@
 # ConsensusActor hierarchy
 # ---------------------------------------------------------------------------
 
+
 class ConsensusActor:
     """Optional plug-in that adds a gradient term to the averaging update.
 
@@ -59,6 +60,7 @@ class NoConsensusActor(ConsensusActor):
 # Message types
 # ---------------------------------------------------------------------------
 
+
 @dataclass
 class AveragingConsensusMessage(OptimizationMessage):
     """Message exchanged between averaging-consensus participants.
@@ -94,6 +96,7 @@ class ConsensusFinishedMessage:
 # AveragingConsensusAlgorithm
 # ---------------------------------------------------------------------------
 
+
 class AveragingConsensusAlgorithm(DistributedAlgorithm):
     """Distributed averaging consensus with an optional gradient correction.
 
@@ -193,6 +196,7 @@ async def on_exchange_message(
 # Factories
 # ---------------------------------------------------------------------------
 
+
 def create_averaging_consensus_participant(
     finish_callback: Callable,
     consensus_actor: ConsensusActor | None = None,

distributed_resource_optimization/algorithm/core.py

@@ -57,6 +57,7 @@ async def start_optimization(
 # Module-level shim functions — preserved for compatibility with carrier code
 # ---------------------------------------------------------------------------
 
+
 async def on_exchange_message(
     algorithm: DistributedAlgorithm,
     carrier: "Carrier",
@@ -81,6 +82,7 @@ async def start_optimization(
 # CoordinatedDistributedAlgorithm
 # ---------------------------------------------------------------------------
 
+
 class CoordinatedDistributedAlgorithm:
     """Bundle of a coordinator and its worker algorithms (informational only)."""
 

distributed_resource_optimization/algorithm/heuristic/cohda/core.py

@@ -33,6 +33,7 @@
 # Data structures
 # ---------------------------------------------------------------------------
 
+
 @dataclass
 class ScheduleSelection:
     """A participant's chosen schedule together with its version counter."""
@@ -43,10 +44,7 @@ class ScheduleSelection:
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, ScheduleSelection):
             return NotImplemented
-        return (
-            np.array_equal(self.schedule, other.schedule)
-            and self.counter == other.counter
-        )
+        return np.array_equal(self.schedule, other.schedule) and self.counter == other.counter
 
     def __hash__(self) -> int:
         return hash((tuple(float(v) for v in self.schedule), self.counter))
@@ -67,8 +65,7 @@ def __eq__(self, other: object) -> bool:
         if set(self.schedule_choices) != set(other.schedule_choices):
             return False
         return all(
-            self.schedule_choices[k] == other.schedule_choices[k]
-            for k in self.schedule_choices
+            self.schedule_choices[k] == other.schedule_choices[k] for k in self.schedule_choices
         )
 
     def __hash__(self) -> int:
@@ -106,9 +103,7 @@ def __eq__(self, other: object) -> bool:
         )
 
     def __hash__(self) -> int:
-        return hash(
-            (self.participant_id, self.schedules.tobytes(), self.perf, self.present)
-        )
+        return hash((self.participant_id, self.schedules.tobytes(), self.perf, self.present))
 
     def __repr__(self) -> str:
         return (
@@ -128,9 +123,8 @@ class TargetParams:
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, TargetParams):
             return NotImplemented
-        return (
-            np.array_equal(self.schedule, other.schedule)
-            and np.array_equal(self.weights, other.weights)
+        return np.array_equal(self.schedule, other.schedule) and np.array_equal(
+            self.weights, other.weights
         )
 
     def __hash__(self) -> int:
@@ -142,10 +136,7 @@ def __hash__(self) -> int:
         )
 
     def __repr__(self) -> str:
-        return (
-            f"TargetParams(schedule={self.schedule.tolist()}, "
-            f"weights={self.weights.tolist()})"
-        )
+        return f"TargetParams(schedule={self.schedule.tolist()}, weights={self.weights.tolist()})"
 
 
 @dataclass
@@ -168,6 +159,7 @@ class WorkingMemory(OptimizationMessage):
 # Default performance function
 # ---------------------------------------------------------------------------
 
+
 def cohda_default_performance(
     cluster_schedule: np.ndarray,
     target_params: TargetParams,
@@ -178,7 +170,7 @@ def cohda_default_performance(
     :param target_params: Target schedule and weights.
     :returns: ``-sum(weights * abs(target - column_sums))``.
     """
-    sum_cs = cluster_schedule.sum(axis=0)           # (n_intervals,)
+    sum_cs = cluster_schedule.sum(axis=0)  # (n_intervals,)
     diff = np.abs(target_params.schedule - sum_cs)
     return -float(np.sum(diff * target_params.weights))
 
@@ -187,6 +179,7 @@ def cohda_default_performance(
 # Local decider hierarchy
 # ---------------------------------------------------------------------------
 
+
 class LocalDecider:
     """Abstract strategy for selecting a local schedule in the decide step."""
 
@@ -218,6 +211,7 @@ def initial_schedule(self, memory: WorkingMemory) -> np.ndarray:
 # COHDAAlgorithmData
 # ---------------------------------------------------------------------------
 
+
 class COHDAAlgorithmData(DistributedAlgorithm):
     """Per-participant COHDA state machine.
 
@@ -255,6 +249,7 @@ async def on_exchange_message(
 # Core algorithmic functions
 # ---------------------------------------------------------------------------
 
+
 def merge_sysconfigs(
     sysconfig_i: SystemConfig,
     sysconfig_j: SystemConfig,
@@ -271,8 +266,7 @@ def merge_sysconfigs(
     modified = False
     for aid in all_ids:
         if aid in choices_i and (
-            aid not in choices_j
-            or choices_i[aid].counter >= choices_j[aid].counter
+            aid not in choices_j or choices_i[aid].counter >= choices_j[aid].counter
         ):
             new_choices[aid] = choices_i[aid]
         else:
@@ -378,9 +372,7 @@ def perceive(
                     counter=cohda_data.counter + 1,
                 )
                 cohda_data.counter += 1
-                current_sysconfig = SystemConfig(
-                    dict(own_memory.system_config.schedule_choices)
-                )
+                current_sysconfig = SystemConfig(dict(own_memory.system_config.schedule_choices))
             else:
                 current_sysconfig = own_memory.system_config
 
@@ -456,9 +448,7 @@ def _decide_default(
     candidate: SolutionCandidate,
 ) -> tuple[SystemConfig, SolutionCandidate]:
     """Evaluate all feasible schedules; keep the best-performing candidate."""
-    possible = [
-        np.array(s, dtype=float) for s in decider.schedule_provider(cohda_data.memory)
-    ]
+    possible = [np.array(s, dtype=float) for s in decider.schedule_provider(cohda_data.memory)]
     current_best = candidate
     if current_best.perf is None:
         current_best = _evaluated(
@@ -469,9 +459,7 @@ def _decide_default(
 
     for schedule in possible:
         if decider.is_local_acceptable(schedule):
-            new_cand = create_from_updated_sysconf(
-                cohda_data.participant_id, sysconfig, schedule
-            )
+            new_cand = create_from_updated_sysconf(cohda_data.participant_id, sysconfig, schedule)
             new_perf = cohda_data.performance_function(
                 new_cand.schedules, cohda_data.memory.target_params
             )
@@ -521,9 +509,7 @@ async def process_exchange_message(
     sysconf, candidate = perceive(algorithm_data, messages)
 
     if sysconf != old_sysconf or candidate != old_candidate:
-        sysconf, candidate = decide(
-            algorithm_data, algorithm_data.decider, sysconf, candidate
-        )
+        sysconf, candidate = decide(algorithm_data, algorithm_data.decider, sysconf, candidate)
         wm = act(algorithm_data, sysconf, candidate)
         for other in carrier.others(str(algorithm_data.participant_id)):
             carrier.send_to_other(wm, other)
@@ -533,6 +519,7 @@ async def process_exchange_message(
 # Factory helpers
 # ---------------------------------------------------------------------------
 
+
 def create_cohda_start_message(
     target_schedule: list[float] | np.ndarray,
     weights: list[float] | np.ndarray | None = None,