Make Node a dataclass

Dataclasses make the code more compact and generate many convenience
functions.

Author: adsharma

quoracle/expr.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass
 from typing import Dict, Iterator, Generic, List, Optional, Set, TypeVar
 import datetime
 import itertools
@@ -89,14 +90,19 @@ def _dup_free_min_failures(self) -> int:
         raise NotImplementedError
 
 
+@dataclass
 class Node(Expr[T]):
-    def __init__(self,
-                 x: T,
-                 capacity: Optional[float] = None,
-                 read_capacity: Optional[float] = None,
-                 write_capacity: Optional[float] = None,
-                 latency: datetime.timedelta = None) -> None:
-        self.x = x
+    x: T
+    capacity: Optional[float] = None
+    read_capacity: Optional[float] = None
+    write_capacity: Optional[float] = None
+    latency: Optional[datetime.timedelta] = None
+
+    def post_init(self):
+        capacity = self.capacity
+        read_capacity = self.read_capacity
+        write_capacity = self.write_capacity
+        latency = self.latency
 
         # A user either specifies capacity or (read_capacity and
         # write_capacity), but not both.
@@ -124,6 +130,8 @@ def __init__(self,
         else:
             self.latency = latency
 
+    def __hash__(self):
+        return self.x.__hash__()
 
     def __str__(self) -> str:
         return str(self.x)

quoracle/quorum_system.py

@@ -520,11 +520,17 @@ def fr_load(problem: pulp.LpProblem, fr: float) -> pulp.LpAffineExpression:
 
                 if x in x_to_read_quorum_vars:
                     vs = x_to_read_quorum_vars[x]
-                    x_load += fr * sum(vs) / self.node(x).read_capacity
+                    xread_capacity =  self.node(x).read_capacity
+                    if xread_capacity is None:
+                        xread_capacity = self.node(x).read_capacity = 1.0
+                    x_load += fr * sum(vs) / xread_capacity
 
                 if x in x_to_write_quorum_vars:
                     vs = x_to_write_quorum_vars[x]
-                    x_load += (1 - fr) * sum(vs) / self.node(x).write_capacity
+                    xwrite_capacity =  self.node(x).write_capacity
+                    if xwrite_capacity is None:
+                        xwrite_capacity = self.node(x).write_capacity = 1.0
+                    x_load += (1 - fr) * sum(vs) / xwrite_capacity
 
                 problem += (x_load <= l, f'{x}{fr}')