src/budget_sync/budget_graph.py

   1 from budget_sync.ordered_set import OrderedSet
   2 from bugzilla.bug import Bug
   3 from typing import Callable, Set, Dict, Iterable, Optional, List, Tuple, Union, Any
   4 from budget_sync.util import BugStatus, PrettyPrinter
   5 from budget_sync.money import Money
   6 from budget_sync.config import Config, Person, Milestone
   7 import toml
   8 import sys
   9 import enum
  10 from collections import deque
  11 from datetime import date, time, datetime
  12 try:
  13     from functools import cached_property
  14 except ImportError:
  15     # compatability with python < 3.8
  16     from cached_property import cached_property
  17
  18
  19 class BudgetGraphBaseError(Exception):
  20     pass
  21
  22
  23 class BudgetGraphParseError(BudgetGraphBaseError):
  24     def __init__(self, bug_id: int):
  25         self.bug_id = bug_id
  26
  27
  28 class BudgetGraphPayeesParseError(BudgetGraphParseError):
  29     def __init__(self, bug_id: int, msg: str):
  30         super().__init__(bug_id)
  31         self.msg = msg
  32
  33     def __str__(self):
  34         return f"Failed to parse cf_payees_list field of " \
  35             f"bug #{self.bug_id}: {self.msg}"
  36
  37
  38 class BudgetGraphUnknownAssignee(BudgetGraphParseError):
  39     def __init__(self, bug_id: int, assignee: str):
  40         super().__init__(bug_id)
  41         self.assignee = assignee
  42
  43     def __str__(self):
  44         return f"Bug #{self.bug_id} is assigned to an unknown person: " \
  45             f"{self.assignee!r}"
  46
  47
  48 class BudgetGraphLoopError(BudgetGraphBaseError):
  49     def __init__(self, bug_ids: List[int]):
  50         self.bug_ids = bug_ids
  51
  52     def __str__(self):
  53         retval = f"Detected Loop in Budget Graph: #{self.bug_ids[-1]} -> "
  54         retval += " -> ".join((f"#{i}" for i in self.bug_ids))
  55         return retval
  56
  57
  58 class _NodeSimpleReprWrapper:
  59     def __init__(self, node: "Node"):
  60         self.node = node
  61
  62     def __repr__(self):
  63         return f"#{self.node.bug.id}"
  64
  65     def __lt__(self, other):
  66         # for list.sort()
  67         return self.node.bug.id < other.node.bug.id
  68
  69
  70 class PayeeState(enum.Enum):
  71     NotYetSubmitted = "not yet submitted"
  72     Submitted = "submitted"
  73     Paid = "paid"
  74
  75
  76 _Date = Union[date, datetime]
  77
  78
  79 def _parse_money_from_toml(value: Any) -> Money:
  80     if not isinstance(value, (int, str)):
  81         msg = f"monetary amount is not a string or integer " \
  82             f"(to use fractional amounts such as 123.45, write " \
  83             f"\"123.45\"): {value!r}"
  84         raise ValueError(msg)
  85     return Money(value)
  86
  87
  88 def _parse_date_time_or_none_from_toml(value: Any) -> Optional[_Date]:
  89     if value is None or isinstance(value, (date, datetime)):
  90         return value
  91     elif isinstance(value, time):
  92         msg = f"just a time of day by itself is not enough," \
  93             f" a date must be included: {str(value)}"
  94         raise ValueError(msg)
  95     elif isinstance(value, bool):
  96         msg = f"invalid date: {str(value).lower()}"
  97         raise ValueError(msg)
  98     elif isinstance(value, (str, int, float)):
  99         msg = f"invalid date: {value!r}"
 100         raise ValueError(msg)
 101     else:
 102         msg = f"invalid date"
 103         raise ValueError(msg)
 104
 105
 106 class Payment:
 107     def __init__(self,
 108                  node: "Node",
 109                  payee_key: str,
 110                  amount: Money,
 111                  paid: Optional[_Date],
 112                  submitted: Optional[_Date]):
 113         self.node = node
 114         self.payee_key = payee_key
 115         self.amount = amount
 116         self.paid = paid
 117         self.submitted = submitted
 118
 119     @cached_property
 120     def payee(self) -> Person:
 121         try:
 122             return self.node.graph.config.all_names[self.payee_key]
 123         except KeyError:
 124             msg = f"unknown payee name: {self.payee_key!r} is not the name " \
 125                 f"or an alias of any known person"
 126             raise BudgetGraphPayeesParseError(self.node.bug.id, msg) \
 127                 .with_traceback(sys.exc_info()[2])
 128
 129     @property
 130     def state(self):
 131         if self.paid is not None:
 132             return PayeeState.Paid
 133         if self.submitted is not None:
 134             return PayeeState.Submitted
 135         return PayeeState.NotYetSubmitted
 136
 137     @staticmethod
 138     def _from_toml(node: "Node", payee_key: str, toml_value: Any) -> "Payment":
 139         paid = None
 140         submitted = None
 141         known_keys = ("paid", "submitted", "amount")
 142         if isinstance(toml_value, dict):
 143             try:
 144                 amount = toml_value['amount']
 145             except KeyError:
 146                 msg = f"value for key {payee_key!r} is missing the " \
 147                     f"`amount` field which is required"
 148                 raise BudgetGraphPayeesParseError(node.bug.id, msg) \
 149                     .with_traceback(sys.exc_info()[2])
 150             for k, v in toml_value.items():
 151                 if k in ("paid", "submitted"):
 152                     try:
 153                         parsed_value = _parse_date_time_or_none_from_toml(v)
 154                     except ValueError as e:
 155                         msg = f"failed to parse `{k}` field for" \
 156                             f" key {payee_key!r}: {e}"
 157                         raise BudgetGraphPayeesParseError(
 158                             node.bug.id, msg) \
 159                             .with_traceback(sys.exc_info()[2])
 160                     if k == "paid":
 161                         paid = parsed_value
 162                     else:
 163                         assert k == "submitted"
 164                         submitted = parsed_value
 165                 if k not in known_keys:
 166                     msg = f"value for key {payee_key!r} has an unknown" \
 167                         f" field: `{k}`"
 168                     raise BudgetGraphPayeesParseError(node.bug.id, msg) \
 169                         .with_traceback(sys.exc_info()[2])
 170             try:
 171                 paid = _parse_date_time_or_none_from_toml(
 172                     toml_value.get('paid'))
 173             except ValueError as e:
 174                 msg = f"failed to parse `paid` field for" \
 175                     f" key {payee_key!r}: {e}"
 176                 raise BudgetGraphPayeesParseError(
 177                     node.bug.id, msg) \
 178                     .with_traceback(sys.exc_info()[2])
 179             try:
 180                 submitted = _parse_date_time_or_none_from_toml(
 181                     toml_value.get('submitted'))
 182             except ValueError as e:
 183                 msg = f"failed to parse `submitted` field for" \
 184                     f" key {payee_key!r}: {e}"
 185                 raise BudgetGraphPayeesParseError(
 186                     node.bug.id, msg) \
 187                     .with_traceback(sys.exc_info()[2])
 188         elif isinstance(toml_value, (int, str, float)):
 189             # float included for better error messages
 190             amount = toml_value
 191         else:
 192             msg = f"value for key {payee_key!r} is invalid -- it should " \
 193                 f"either be a monetary value or a table"
 194             raise BudgetGraphPayeesParseError(node.bug.id, msg)
 195         try:
 196             amount = _parse_money_from_toml(amount)
 197         except ValueError as e:
 198             msg = f"failed to parse monetary amount for key {payee_key!r}: {e}"
 199             raise BudgetGraphPayeesParseError(
 200                 node.bug.id, msg) \
 201                 .with_traceback(sys.exc_info()[2])
 202         return Payment(node=node, payee_key=payee_key, amount=amount,
 203                        paid=paid, submitted=submitted)
 204
 205     def __repr__(self):
 206         try:
 207             payee = f"Person<{self.payee.identifier!r}>"
 208         except BudgetGraphBaseError:
 209             payee = "<unknown person>"
 210         return (f"Payment(node={_NodeSimpleReprWrapper(self.node)}, "
 211                 f"payee={payee}, "
 212                 f"payee_key={self.payee_key!r}, "
 213                 f"amount={self.amount}, "
 214                 f"state={self.state.name}, "
 215                 f"paid={str(self.paid)}, "
 216                 f"submitted={str(self.submitted)})")
 217
 218
 219 @enum.unique
 220 class PaymentSummaryState(enum.Enum):
 221     Submitted = PayeeState.Submitted
 222     Paid = PayeeState.Paid
 223     NotYetSubmitted = PayeeState.NotYetSubmitted
 224     Inconsistent = None
 225
 226
 227 class PaymentSummary:
 228     total_submitted: Money
 229     """includes amount paid"""
 230
 231     def __init__(self, payments: Iterable[Payment]):
 232         self.payments = tuple(payments)
 233         self.total = Money(0)
 234         self.total_paid = Money(0)
 235         self.total_submitted = Money(0)
 236         self.submitted_date = None
 237         self.paid_date = None
 238         self.not_submitted = []
 239         summary_state = None
 240         for payment in self.payments:
 241             if summary_state is None:
 242                 summary_state = PaymentSummaryState(payment.state)
 243                 self.submitted_date = payment.submitted
 244                 self.paid_date = payment.paid
 245             elif summary_state != PaymentSummaryState(payment.state) \
 246                     or self.submitted_date != payment.submitted \
 247                     or self.paid_date != payment.paid:
 248                 summary_state = PaymentSummaryState.Inconsistent
 249                 self.paid_date = None
 250                 self.submitted_date = None
 251             self.total += payment.amount
 252             if payment.state is PayeeState.Submitted:
 253                 self.total_submitted += payment.amount
 254             elif payment.state is PayeeState.Paid:
 255                 self.total_submitted += payment.amount
 256                 self.total_paid += payment.amount
 257             else:
 258                 assert payment.state is PayeeState.NotYetSubmitted
 259                 self.not_submitted.append(payment.node.bug.id)
 260         if summary_state is None:
 261             self.state = PaymentSummaryState.NotYetSubmitted
 262         else:
 263             self.state = summary_state
 264
 265     def get_not_submitted(self):
 266         return self.not_submitted
 267
 268     def __repr__(self) -> str:
 269         return (f"PaymentSummary(total={self.total}, "
 270                 f"total_paid={self.total_paid}, "
 271                 f"total_submitted={self.total_submitted}, "
 272                 f"submitted_date={self.submitted_date}, "
 273                 f"paid_date={self.paid_date}, "
 274                 f"state={self.state}, "
 275                 f"payments={self.payments})")
 276
 277     def __pretty_print__(self, pp: PrettyPrinter):
 278         with pp.type_pp("PaymentSummary") as tpp:
 279             tpp.field("total", self.total)
 280             tpp.field("total_submitted", self.total_submitted)
 281             tpp.field("submitted_date", self.submitted_date)
 282             tpp.field("paid_date", self.paid_date)
 283             tpp.field("state", self.state)
 284             tpp.field("payments", self.payments)
 285
 286
 287 class BudgetGraphUnknownMilestone(BudgetGraphParseError):
 288     def __init__(self, bug_id: int, milestone_str: str):
 289         super().__init__(bug_id)
 290         self.milestone_str = milestone_str
 291
 292     def __str__(self):
 293         return f"failed to parse cf_nlnet_milestone field of bug " \
 294             f"#{self.bug_id}: unknown milestone: {self.milestone_str!r}"
 295
 296
 297 class BudgetGraphUnknownStatus(BudgetGraphParseError):
 298     def __init__(self, bug_id: int, status_str: str):
 299         super().__init__(bug_id)
 300         self.status_str = status_str
 301
 302     def __str__(self):
 303         return f"failed to parse status field of bug " \
 304             f"#{self.bug_id}: unknown status: {self.status_str!r}"
 305
 306
 307 class Node:
 308     graph: "BudgetGraph"
 309     bug: Bug
 310     parent_id: Optional[int]
 311     immediate_children: OrderedSet["Node"]
 312     budget_excluding_subtasks: Money
 313     budget_including_subtasks: Money
 314     fixed_budget_excluding_subtasks: Money
 315     fixed_budget_including_subtasks: Money
 316     milestone_str: Optional[str]
 317
 318     def __init__(self, graph: "BudgetGraph", bug: Bug):
 319         self.graph = graph
 320         self.bug = bug
 321         self.parent_id = getattr(bug, "cf_budget_parent", None)
 322         self.immediate_children = OrderedSet()
 323         self.budget_excluding_subtasks = Money.from_str(bug.cf_budget)
 324         self.fixed_budget_excluding_subtasks = self.budget_excluding_subtasks
 325         self.budget_including_subtasks = Money.from_str(bug.cf_total_budget)
 326         self.fixed_budget_including_subtasks = self.budget_including_subtasks
 327         self.milestone_str = bug.cf_nlnet_milestone
 328         if self.milestone_str == "---":
 329             self.milestone_str = None
 330
 331     @property
 332     def status(self) -> BugStatus:
 333         try:
 334             return BugStatus.cast(self.bug.status)
 335         except ValueError:
 336             new_err = BudgetGraphUnknownStatus(self.bug.id, self.bug.status)
 337             raise new_err.with_traceback(sys.exc_info()[2])
 338
 339     @cached_property
 340     def assignee(self) -> Person:
 341         try:
 342             return self.graph.config.all_names[self.bug.assigned_to]
 343         except KeyError:
 344             raise BudgetGraphUnknownAssignee(self.bug.id,
 345                                              self.bug.assigned_to) \
 346                 .with_traceback(sys.exc_info()[2])
 347
 348     @cached_property
 349     def bug_url(self) -> str:
 350         return f"{self.graph.config.bugzilla_url_stripped}/show_bug.cgi?" \
 351             f"id={self.bug.id}"
 352
 353     @cached_property
 354     def milestone(self) -> Optional[Milestone]:
 355         if self.milestone_str is None:
 356             return None
 357         try:
 358             return self.graph.config.milestones[self.milestone_str]
 359         except KeyError:
 360             new_err = BudgetGraphUnknownMilestone(
 361                 self.bug.id, self.milestone_str)
 362             raise new_err.with_traceback(sys.exc_info()[2])
 363
 364     @cached_property
 365     def payments(self) -> Dict[str, Payment]:
 366         try:
 367             parsed = toml.loads(self.bug.cf_payees_list)
 368         except toml.TomlDecodeError as e:
 369             new_err = BudgetGraphPayeesParseError(
 370                 self.bug.id, f"TOML parse error: {e}")
 371             raise new_err.with_traceback(sys.exc_info()[2])
 372         retval = {}
 373         for key, value in parsed.items():
 374             if not isinstance(key, str):
 375                 raise BudgetGraphPayeesParseError(
 376                     self.bug.id, f"key is not a string: {key!r}")
 377             retval[key] = Payment._from_toml(self, key, value)
 378         return retval
 379
 380     @cached_property
 381     def resolved_payments(self) -> Dict[Person, List[Payment]]:
 382         retval: Dict[Person, List[Payment]] = {}
 383         for payment in self.payments.values():
 384             if payment.payee not in retval:
 385                 retval[payment.payee] = []
 386             retval[payment.payee].append(payment)
 387         return retval
 388
 389     @cached_property
 390     def payment_summaries(self) -> Dict[Person, PaymentSummary]:
 391         return {person: PaymentSummary(payments)
 392                 for person, payments in self.resolved_payments.items()}
 393
 394     @cached_property
 395     def submitted_excluding_subtasks(self) -> Money:
 396         retval = Money()
 397         for payment in self.payments.values():
 398             if payment.submitted is not None or payment.paid is not None:
 399                 retval += payment.amount
 400         return retval
 401
 402     @cached_property
 403     def paid_excluding_subtasks(self) -> Money:
 404         retval = Money()
 405         for payment in self.payments.values():
 406             if payment.paid is not None:
 407                 retval += payment.amount
 408         return retval
 409
 410     @property
 411     def parent(self) -> Optional["Node"]:
 412         if self.parent_id is not None:
 413             return self.graph.nodes[self.parent_id]
 414         return None
 415
 416     def parents(self) -> Iterable["Node"]:
 417         parent = self.parent
 418         while parent is not None:
 419             yield parent
 420             parent = parent.parent
 421
 422     def _raise_loop_error(self):
 423         bug_ids = []
 424         for parent in self.parents():
 425             bug_ids.append(parent.bug.id)
 426             if parent == self:
 427                 break
 428         raise BudgetGraphLoopError(bug_ids)
 429
 430     @cached_property
 431     def root(self) -> "Node":
 432         # also checks for loop errors
 433         retval = self
 434         for parent in self.parents():
 435             retval = parent
 436             if parent == self:
 437                 self._raise_loop_error()
 438         return retval
 439
 440     def children(self) -> Iterable["Node"]:
 441         def visitor(node: Node) -> Iterable[Node]:
 442             for i in node.immediate_children:
 443                 yield i
 444                 yield from visitor(i)
 445         return visitor(self)
 446
 447     def children_breadth_first(self) -> Iterable["Node"]:
 448         q = deque(self.immediate_children)
 449         while True:
 450             try:
 451                 node = q.popleft()
 452             except IndexError:
 453                 return
 454             q.extend(node.immediate_children)
 455             yield node
 456
 457     def __eq__(self, other):
 458         return self.bug.id == other.bug.id
 459
 460     def __hash__(self):
 461         return self.bug.id
 462
 463     def __pretty_print__(self, pp: PrettyPrinter):
 464         with pp.type_pp("Node") as tpp:
 465             tpp.field("graph", ...)
 466             tpp.field("id", _NodeSimpleReprWrapper(self))
 467             tpp.try_field("root",
 468                           lambda: _NodeSimpleReprWrapper(self.root),
 469                           BudgetGraphLoopError)
 470             parent = f"#{self.parent_id}" if self.parent_id is not None else None
 471             tpp.field("parent", parent)
 472             tpp.field("budget_excluding_subtasks",
 473                       self.budget_excluding_subtasks)
 474             tpp.field("budget_including_subtasks",
 475                       self.budget_including_subtasks)
 476             tpp.field("fixed_budget_excluding_subtasks",
 477                       self.fixed_budget_excluding_subtasks)
 478             tpp.field("fixed_budget_including_subtasks",
 479                       self.fixed_budget_including_subtasks)
 480             tpp.field("milestone_str", self.milestone_str)
 481             tpp.try_field("milestone", lambda: self.milestone,
 482                           BudgetGraphBaseError)
 483             immediate_children = [_NodeSimpleReprWrapper(i)
 484                                   for i in self.immediate_children]
 485             tpp.field("immediate_children", immediate_children)
 486             tpp.try_field("payments",
 487                           lambda: list(self.payments.values()),
 488                           BudgetGraphBaseError)
 489             try:
 490                 status = repr(self.status)
 491             except BudgetGraphBaseError:
 492                 status = f"<unknown status: {self.bug.status!r}>"
 493             tpp.field("status", status)
 494             try:
 495                 assignee = f"Person<{self.assignee.identifier!r}>"
 496             except BudgetGraphBaseError:
 497                 assignee = f"<unknown assignee: {self.bug.assigned_to!r}>"
 498             tpp.field("assignee", assignee)
 499             tpp.try_field("resolved_payments",
 500                           lambda: self.resolved_payments,
 501                           BudgetGraphBaseError)
 502             tpp.try_field("payment_summaries",
 503                           lambda: self.payment_summaries,
 504                           BudgetGraphBaseError)
 505
 506     def __repr__(self):
 507         try:
 508             root = _NodeSimpleReprWrapper(self.root)
 509         except BudgetGraphLoopError:
 510             root = "<loop error>"
 511         try:
 512             milestone = repr(self.milestone)
 513         except BudgetGraphBaseError:
 514             milestone = "<unknown milestone>"
 515         try:
 516             status = repr(self.status)
 517         except BudgetGraphBaseError:
 518             status = f"<unknown status: {self.bug.status!r}>"
 519         try:
 520             assignee = f"Person<{self.assignee.identifier!r}>"
 521         except BudgetGraphBaseError:
 522             assignee = f"<unknown assignee: {self.bug.assigned_to!r}>"
 523         immediate_children = []
 524         for i in self.immediate_children:
 525             immediate_children.append(_NodeSimpleReprWrapper(i))
 526         immediate_children.sort()
 527         parent = f"#{self.parent_id}" if self.parent_id is not None else None
 528         payments = list(self.payments.values())
 529         resolved_payments = self.resolved_payments
 530         payment_summaries = self.payment_summaries
 531         return (f"Node(graph=..., "
 532                 f"id={_NodeSimpleReprWrapper(self)}, "
 533                 f"root={root}, "
 534                 f"parent={parent}, "
 535                 f"budget_excluding_subtasks={self.budget_excluding_subtasks}, "
 536                 f"budget_including_subtasks={self.budget_including_subtasks}, "
 537                 f"fixed_budget_excluding_subtasks={self.fixed_budget_excluding_subtasks}, "
 538                 f"fixed_budget_including_subtasks={self.fixed_budget_including_subtasks}, "
 539                 f"milestone_str={self.milestone_str!r}, "
 540                 f"milestone={milestone}, "
 541                 f"immediate_children={immediate_children!r}, "
 542                 f"payments={payments!r}, "
 543                 f"status={status}, "
 544                 f"assignee={assignee}, "
 545                 f"resolved_payments={resolved_payments!r}, "
 546                 f"payment_summaries={payment_summaries!r})")
 547
 548
 549 class BudgetGraphError(BudgetGraphBaseError):
 550     def __init__(self, bug_id: int, root_bug_id: int):
 551         self.bug_id = bug_id
 552         self.root_bug_id = root_bug_id
 553
 554
 555 class BudgetGraphMoneyWithNoMilestone(BudgetGraphError):
 556     def __str__(self):
 557         return (f"Bug assigned money but without"
 558                 f" any assigned milestone: #{self.bug_id}")
 559
 560
 561 class BudgetGraphMilestoneMismatch(BudgetGraphError):
 562     def __str__(self):
 563         return (f"Bug's assigned milestone doesn't match the milestone "
 564                 f"assigned to the root bug: descendant bug"
 565                 f" #{self.bug_id}, root bug"
 566                 f" #{self.root_bug_id}")
 567
 568
 569 class BudgetGraphMoneyMismatchForBudgetExcludingSubtasks(BudgetGraphError):
 570     def __init__(self, bug_id: int, root_bug_id: int,
 571                  expected_budget_excluding_subtasks: Money):
 572         super().__init__(bug_id, root_bug_id)
 573         self.expected_budget_excluding_subtasks = \
 574             expected_budget_excluding_subtasks
 575
 576     def __str__(self):
 577         return (f"Budget assigned to task excluding subtasks "
 578                 f"(cf_budget field) doesn't match calculated value: "
 579                 f"bug #{self.bug_id}, calculated value"
 580                 f" {self.expected_budget_excluding_subtasks}")
 581
 582
 583 class BudgetGraphMoneyMismatchForBudgetIncludingSubtasks(BudgetGraphError):
 584     def __init__(self, bug_id: int, root_bug_id: int,
 585                  expected_budget_including_subtasks: Money):
 586         super().__init__(bug_id, root_bug_id)
 587         self.expected_budget_including_subtasks = \
 588             expected_budget_including_subtasks
 589
 590     def __str__(self):
 591         return (f"Budget assigned to task including subtasks "
 592                 f"(cf_total_budget field) doesn't match calculated value: "
 593                 f"bug #{self.bug_id}, calculated value"
 594                 f" {self.expected_budget_including_subtasks}")
 595
 596
 597 class BudgetGraphNegativeMoney(BudgetGraphError):
 598     def __str__(self):
 599         return (f"Budget assigned to task is less than zero: "
 600                 f"bug #{self.bug_id}")
 601
 602
 603 class BudgetGraphPayeesMoneyMismatch(BudgetGraphError):
 604     def __init__(self, bug_id: int, root_bug_id: int, payees_total: Money,
 605                  expected_payees_total: Money):
 606         super().__init__(bug_id, root_bug_id)
 607         self.payees_total = payees_total
 608         self.expected_payees_total = expected_payees_total
 609
 610     def __str__(self):
 611         return (f"Total budget assigned to payees (cf_payees_list) doesn't "
 612                 f"match expected value: bug #{self.bug_id}, calculated total "
 613                 f"{self.payees_total}, expected value "
 614                 f"{self.expected_payees_total}")
 615
 616
 617 class BudgetGraphNegativePayeeMoney(BudgetGraphError):
 618     def __init__(self, bug_id: int, root_bug_id: int, payee_key: str):
 619         super().__init__(bug_id, root_bug_id)
 620         self.payee_key = payee_key
 621
 622     def __str__(self):
 623         return (f"Budget assigned to payee for task is less than zero: "
 624                 f"bug #{self.bug_id}, payee {self.payee_key!r}")
 625
 626
 627 class BudgetGraphIncorrectRootForMilestone(BudgetGraphError):
 628     def __init__(self, bug_id: int, milestone: str, milestone_canonical_bug_id: int):
 629         super().__init__(bug_id, bug_id)
 630         self.milestone = milestone
 631         self.milestone_canonical_bug_id = milestone_canonical_bug_id
 632
 633     def __str__(self):
 634         return (f"Bug #{self.bug_id} is not the canonical root bug for "
 635                 f"assigned milestone {self.milestone!r} but has no parent "
 636                 f"bug set: the milestone's canonical root bug is "
 637                 f"#{self.milestone_canonical_bug_id}")
 638
 639
 640 class BudgetGraph:
 641     nodes: Dict[int, Node]
 642
 643     def __init__(self, bugs: Iterable[Bug], config: Config):
 644         self.nodes = {}
 645         self.config = config
 646         for bug in bugs:
 647             self.nodes[bug.id] = Node(self, bug)
 648         for node in self.nodes.values():
 649             if node.parent is None:
 650                 continue
 651             node.parent.immediate_children.add(node)
 652         # useful debug prints
 653         # for bug in bugs:
 654         #    node = self.nodes[bug.id]
 655         #    print ("bug added", bug.id, node, node.parent.immediate_children)
 656
 657     @cached_property
 658     def roots(self) -> OrderedSet[Node]:
 659         roots = OrderedSet()
 660         for node in self.nodes.values():
 661             # calling .root also checks for loop errors
 662             root = node.root
 663             roots.add(root)
 664         return roots
 665
 666     def _get_node_errors(self, root: Node, node: Node,
 667                          errors: List[BudgetGraphBaseError]):
 668         if node.milestone_str is None:
 669             if node.budget_including_subtasks != 0 \
 670                     or node.budget_excluding_subtasks != 0:
 671                 errors.append(BudgetGraphMoneyWithNoMilestone(
 672                     node.bug.id, root.bug.id))
 673
 674         try:
 675             # check for milestone errors
 676             node.milestone
 677             if root == node and node.milestone is not None \
 678                     and node.milestone.canonical_bug_id != node.bug.id:
 679                 if node.budget_including_subtasks != 0 \
 680                         or node.budget_excluding_subtasks != 0:
 681                     errors.append(BudgetGraphIncorrectRootForMilestone(
 682                         node.bug.id, node.milestone.identifier,
 683                         node.milestone.canonical_bug_id
 684                     ))
 685         except BudgetGraphBaseError as e:
 686             errors.append(e)
 687
 688         try:
 689             # check for status errors
 690             node.status
 691         except BudgetGraphBaseError as e:
 692             errors.append(e)
 693
 694         try:
 695             # check for assignee errors
 696             node.assignee
 697         except BudgetGraphBaseError as e:
 698             errors.append(e)
 699
 700         if node.milestone_str != root.milestone_str:
 701             errors.append(BudgetGraphMilestoneMismatch(
 702                 node.bug.id, root.bug.id))
 703
 704         if node.budget_excluding_subtasks < 0 \
 705                 or node.budget_including_subtasks < 0:
 706             errors.append(BudgetGraphNegativeMoney(
 707                 node.bug.id, root.bug.id))
 708
 709         childlist = []
 710         subtasks_total = Money(0)
 711         for child in node.immediate_children:
 712             subtasks_total += child.fixed_budget_including_subtasks
 713             childlist.append(child.bug.id)
 714         # useful debug prints
 715         # print ("subtask total", node.bug.id, root.bug.id, subtasks_total,
 716         #                        childlist)
 717
 718         payees_total = Money(0)
 719         payee_payments: Dict[Person, List[Payment]] = {}
 720         for payment in node.payments.values():
 721             if payment.amount < 0:
 722                 errors.append(BudgetGraphNegativePayeeMoney(
 723                     node.bug.id, root.bug.id, payment.payee_key))
 724             payees_total += payment.amount
 725             try:
 726                 # check for payee errors
 727                 payment.payee
 728                 previous_payment = payee_payments.get(payment.payee)
 729                 if previous_payment is not None:
 730                     payee_payments[payment.payee].append(payment)
 731                 else:
 732                     payee_payments[payment.payee] = [payment]
 733             except BudgetGraphBaseError as e:
 734                 errors.append(e)
 735
 736         def set_including_from_excluding_and_error():
 737             node.fixed_budget_including_subtasks = \
 738                 node.budget_excluding_subtasks + subtasks_total
 739             errors.append(
 740                 BudgetGraphMoneyMismatchForBudgetIncludingSubtasks(
 741                     node.bug.id, root.bug.id,
 742                     node.fixed_budget_including_subtasks))
 743
 744         def set_including_from_payees_and_error():
 745             node.fixed_budget_including_subtasks = \
 746                 payees_total + subtasks_total
 747             errors.append(
 748                 BudgetGraphMoneyMismatchForBudgetIncludingSubtasks(
 749                     node.bug.id, root.bug.id,
 750                     node.fixed_budget_including_subtasks))
 751
 752         def set_excluding_from_including_and_error():
 753             node.fixed_budget_excluding_subtasks = \
 754                 node.budget_including_subtasks - subtasks_total
 755             errors.append(
 756                 BudgetGraphMoneyMismatchForBudgetExcludingSubtasks(
 757                     node.bug.id, root.bug.id,
 758                     node.fixed_budget_excluding_subtasks))
 759
 760         def set_excluding_from_payees_and_error():
 761             node.fixed_budget_excluding_subtasks = \
 762                 payees_total
 763             errors.append(
 764                 BudgetGraphMoneyMismatchForBudgetExcludingSubtasks(
 765                     node.bug.id, root.bug.id,
 766                     node.fixed_budget_excluding_subtasks))
 767
 768         def set_payees_from_including_and_error():
 769             fixed_payees_total = \
 770                 node.budget_including_subtasks - subtasks_total
 771             errors.append(BudgetGraphPayeesMoneyMismatch(
 772                 node.bug.id, root.bug.id, payees_total, fixed_payees_total))
 773
 774         def set_payees_from_excluding_and_error():
 775             fixed_payees_total = \
 776                 node.budget_excluding_subtasks
 777             errors.append(BudgetGraphPayeesMoneyMismatch(
 778                 node.bug.id, root.bug.id, payees_total, fixed_payees_total))
 779
 780         payees_matches_including = \
 781             node.budget_including_subtasks - subtasks_total == payees_total
 782         payees_matches_excluding = \
 783             node.budget_excluding_subtasks == payees_total
 784         including_matches_excluding = \
 785             node.budget_including_subtasks - subtasks_total \
 786             == node.budget_excluding_subtasks
 787
 788         if payees_matches_including \
 789                 and payees_matches_excluding \
 790                 and including_matches_excluding:
 791             pass  # no error
 792         elif payees_matches_including:
 793             # can't have 2 match without all 3 matching
 794             assert not payees_matches_excluding
 795             assert not including_matches_excluding
 796             if node.budget_including_subtasks == 0 and len(node.payments) == 0:
 797                 set_including_from_excluding_and_error()
 798             else:
 799                 set_excluding_from_including_and_error()
 800         elif payees_matches_excluding:
 801             # can't have 2 match without all 3 matching
 802             assert not payees_matches_including
 803             assert not including_matches_excluding
 804             if node.budget_excluding_subtasks == 0 and len(node.payments) == 0:
 805                 if node.budget_including_subtasks == 0:
 806                     set_including_from_excluding_and_error()
 807                 else:
 808                     set_excluding_from_including_and_error()
 809             else:
 810                 set_including_from_excluding_and_error()
 811         elif including_matches_excluding:
 812             # can't have 2 match without all 3 matching
 813             assert not payees_matches_including
 814             assert not payees_matches_excluding
 815             if len(node.payments) == 0:
 816                 pass  # no error -- payees is just not set
 817             elif node.budget_excluding_subtasks == 0 \
 818                     and node.budget_including_subtasks == 0:
 819                 set_excluding_from_payees_and_error()
 820                 set_including_from_payees_and_error()
 821             else:
 822                 set_payees_from_excluding_and_error()
 823         else:
 824             # nothing matches
 825             if len(node.payments) == 0:
 826                 # payees unset -- don't need to set payees
 827                 if node.budget_including_subtasks == 0:
 828                     set_including_from_excluding_and_error()
 829                 else:
 830                     set_excluding_from_including_and_error()
 831             elif node.budget_excluding_subtasks == 0 \
 832                     and node.budget_including_subtasks == 0:
 833                 set_excluding_from_payees_and_error()
 834                 set_including_from_payees_and_error()
 835             elif node.budget_excluding_subtasks == 0:
 836                 set_excluding_from_including_and_error()
 837                 set_payees_from_including_and_error()
 838             elif node.budget_including_subtasks == 0:
 839                 set_including_from_excluding_and_error()
 840                 set_payees_from_excluding_and_error()
 841             else:
 842                 set_including_from_excluding_and_error()
 843                 set_payees_from_excluding_and_error()
 844
 845     def get_errors(self) -> List[BudgetGraphBaseError]:
 846         errors = []
 847         try:
 848             roots = self.roots
 849         except BudgetGraphBaseError as e:
 850             errors.append(e)
 851             return errors
 852
 853         for root in roots:
 854             try:
 855                 for child in reversed(list(root.children_breadth_first())):
 856                     try:
 857                         self._get_node_errors(root, child, errors)
 858                     except BudgetGraphBaseError as e:
 859                         errors.append(e)
 860                 self._get_node_errors(root, root, errors)
 861             except BudgetGraphBaseError as e:
 862                 errors.append(e)
 863         return errors
 864
 865     @cached_property
 866     def assigned_nodes(self) -> Dict[Person, List[Node]]:
 867         retval: Dict[Person, List[Node]]
 868         retval = {person: [] for person in self.config.people.values()}
 869         for node in self.nodes.values():
 870             retval[node.assignee].append(node)
 871         return retval
 872
 873     @cached_property
 874     def assigned_nodes_for_milestones(self) -> Dict[Milestone, List[Node]]:
 875         retval: Dict[Milestone, List[Node]]
 876         retval = {milestone: []
 877                   for milestone in self.config.milestones.values()}
 878         for node in self.nodes.values():
 879             if node.milestone is not None:
 880                 retval[node.milestone].append(node)
 881         return retval
 882
 883     @cached_property
 884     def milestone_payments(self) -> Dict[Milestone, List[Payment]]:
 885         retval: Dict[Milestone, List[Payment]] = {
 886             milestone: [] for milestone in self.config.milestones.values()
 887         }
 888         for node in self.nodes.values():
 889             if node.milestone is not None:
 890                 retval[node.milestone].extend(node.payments.values())
 891         return retval
 892
 893     @cached_property
 894     def payments(self) -> Dict[Person, Dict[Milestone, List[Payment]]]:
 895         retval: Dict[Person, Dict[Milestone, List[Payment]]] = {
 896             person: {
 897                 milestone: []
 898                 for milestone in self.config.milestones.values()
 899             }
 900             for person in self.config.people.values()
 901         }
 902         for node in self.nodes.values():
 903             if node.milestone is not None:
 904                 for payment in node.payments.values():
 905                     retval[payment.payee][node.milestone].append(payment)
 906         return retval
 907
 908     @cached_property
 909     def milestone_people(self) -> Dict[Milestone, OrderedSet[Person]]:
 910         """get a list of people associated with each milestone
 911         """
 912         payments = list(self.payments)  # just activate the payments
 913         retval = {}
 914         for milestone in self.milestone_payments.keys():
 915             retval[milestone] = OrderedSet()
 916         for milestone, payments in self.milestone_payments.items():
 917             for payment in payments:
 918                 retval[milestone].add(payment.payee)
 919         return retval
 920
 921     def __pretty_print__(self, pp: PrettyPrinter):
 922         with pp.type_pp("BudgetGraph") as tpp:
 923             tpp.field("nodes", self.nodes)
 924             tpp.try_field("roots",
 925                           lambda: [_NodeSimpleReprWrapper(i)
 926                                    for i in self.roots],
 927                           BudgetGraphBaseError)
 928             tpp.try_field("assigned_nodes",
 929                           lambda: {
 930                               person: [
 931                                   _NodeSimpleReprWrapper(node)
 932                                   for node in nodes
 933                               ]
 934                               for person, nodes in self.assigned_nodes.items()
 935                           },
 936                           BudgetGraphBaseError)
 937             tpp.try_field("assigned_nodes_for_milestones",
 938                           lambda: {
 939                               milestone: [
 940                                   _NodeSimpleReprWrapper(node)
 941                                   for node in nodes
 942                               ]
 943                               for milestone, nodes in self.assigned_nodes_for_milestones.items()
 944                           },
 945                           BudgetGraphBaseError)
 946             tpp.try_field("payments",
 947                           lambda: self.payments, BudgetGraphBaseError)
 948             tpp.try_field("milestone_people",
 949                           lambda: self.milestone_people,
 950                           BudgetGraphBaseError)
 951
 952     def __repr__(self):
 953         nodes = [*self.nodes.values()]
 954
 955         def repr_or_failed(f: Callable[[], Any]) -> str:
 956             try:
 957                 return repr(f())
 958             except BudgetGraphBaseError:
 959                 return "<failed>"
 960
 961         try:
 962             roots = [_NodeSimpleReprWrapper(i) for i in self.roots]
 963             roots.sort()
 964             roots_str = repr(roots)
 965         except BudgetGraphBaseError:
 966             roots_str = "<failed>"
 967         assigned_nodes = repr_or_failed(lambda: {
 968             person: [
 969                 _NodeSimpleReprWrapper(node)
 970                 for node in nodes
 971             ]
 972             for person, nodes in self.assigned_nodes.items()
 973         })
 974         assigned_nodes_for_milestones = repr_or_failed(lambda: {
 975             milestone: [
 976                 _NodeSimpleReprWrapper(node)
 977                 for node in nodes
 978             ]
 979             for milestone, nodes in self.assigned_nodes_for_milestones.items()
 980         })
 981         milestone_payments = repr_or_failed(lambda: self.milestone_payments)
 982         payments = repr_or_failed(lambda: self.payments)
 983         milestone_people = repr_or_failed(lambda: self.milestone_people)
 984         return (f"BudgetGraph{{nodes={nodes!r}, "
 985                 f"roots={roots}, "
 986                 f"assigned_nodes={assigned_nodes}, "
 987                 f"assigned_nodes_for_milestones={assigned_nodes_for_milestones}, "
 988                 f"milestone_payments={milestone_payments}, "
 989                 f"payments={payments}, "
 990                 f"milestone_people={milestone_people}}}")