Accepted amount for a debit note/invoice is decided in the MarketStrategy (#954)

Author: johny-b

docs/sphinx/api.rst

@@ -101,7 +101,8 @@ Market strategies
 ==========================
 
 .. autoclass:: yapapi.strategy.MarketStrategy
-    :members: decorate_demand, score_offer, respond_to_provider_offer, acceptable_prop_value_range_overrides, acceptable_prop_value_ranges
+    :members: decorate_demand, score_offer, respond_to_provider_offer, acceptable_prop_value_range_overrides, acceptable_prop_value_ranges,
+              invoice_accepted_amount, debit_note_accepted_amount
 
 .. autoclass:: yapapi.strategy.WrappingMarketStrategy
     :members: __init__, base_strategy

yapapi/engine.py

@@ -400,7 +400,9 @@ async def accept_payments_for_agreement(self, job_id: str, agreement_id: str) ->
 
     async def _agreement_payment_attempt(self, agreement_id: str) -> None:
         invoice_manager = self._invoice_manager
-        paid = await invoice_manager.attempt_payment(agreement_id, self._get_allocation)
+        paid = await invoice_manager.attempt_payment(
+            agreement_id, self._get_allocation, self._strategy.invoice_accepted_amount
+        )
         if paid:
             #   We've accepted the final invoice, so we can ignore debit notes
             job_id = invoice_manager.agreement_job(agreement_id).id
@@ -561,12 +563,25 @@ async def _process_debit_note(self, debit_note_id: str) -> None:
 
             try:
                 allocation = self._get_allocation(debit_note)
-                await debit_note.accept(amount=debit_note.total_amount_due, allocation=allocation)
-                job.emit(
-                    events.DebitNoteAccepted,
-                    agreement=agreement,
-                    debit_note=debit_note,
-                )
+                accepted_amount = await self._strategy.debit_note_accepted_amount(debit_note)
+                if accepted_amount >= Decimal(debit_note.total_amount_due):
+                    await debit_note.accept(
+                        amount=debit_note.total_amount_due, allocation=allocation
+                    )
+                    job.emit(
+                        events.DebitNoteAccepted,
+                        agreement=agreement,
+                        debit_note=debit_note,
+                    )
+                else:
+                    #   We should reject the debit note, but it's not implemented in yagna,
+                    #   so we just ignore it now
+                    logger.warning(
+                        "Ignored debit note %s for %s, we accept only %s",
+                        debit_note.debit_note_id,
+                        debit_note.total_amount_due,
+                        accepted_amount,
+                    )
             except CancelledError:
                 raise
             except Exception:

yapapi/invoice_manager.py

@@ -1,6 +1,7 @@
 from asyncio import CancelledError
 from dataclasses import dataclass
-from typing import Callable, Dict, Optional, Set, TYPE_CHECKING
+from decimal import Decimal
+from typing import Awaitable, Callable, Dict, Optional, Set, TYPE_CHECKING
 import sys
 
 from yapapi import events
@@ -20,6 +21,11 @@ class AgreementData:
     paid: bool = False
 
 
+import logging
+
+logger = logging.getLogger(__name__)
+
+
 class InvoiceManager:
     def __init__(self):
         self._agreement_data: Dict[str, AgreementData] = {}
@@ -71,7 +77,10 @@ def set_payable(self, agreement_id: str) -> None:
         self._agreement_data[agreement_id].payable = True
 
     async def attempt_payment(
-        self, agreement_id: str, get_allocation: Callable[["Invoice"], "Allocation"]
+        self,
+        agreement_id: str,
+        get_allocation: Callable[["Invoice"], "Allocation"],
+        get_accepted_amount: Callable[["Invoice"], Awaitable[Decimal]],
     ) -> bool:
         ad = self._agreement_data.get(agreement_id)
         if not ad or not ad.invoice or not ad.payable or ad.paid:
@@ -80,12 +89,23 @@ async def attempt_payment(
         invoice = ad.invoice
         try:
             allocation = get_allocation(invoice)
-            await invoice.accept(amount=invoice.amount, allocation=allocation)
-            ad.job.emit(
-                events.InvoiceAccepted,
-                agreement=ad.agreement,
-                invoice=invoice,
-            )
+            accepted_amount = await get_accepted_amount(invoice)
+            if accepted_amount >= Decimal(invoice.amount):
+                await invoice.accept(amount=accepted_amount, allocation=allocation)
+                ad.job.emit(
+                    events.InvoiceAccepted,
+                    agreement=ad.agreement,
+                    invoice=invoice,
+                )
+            else:
+                #   We should reject the invoice, but it's not implemented in yagna,
+                #   so we just ignore it now
+                logger.warning(
+                    "Ignored invoice %s for %s, we accept only %s",
+                    invoice.invoice_id,
+                    invoice.amount,
+                    accepted_amount,
+                )
         except CancelledError:
             raise
         except Exception:

yapapi/strategy/base.py

@@ -3,6 +3,7 @@
 import abc
 from copy import deepcopy
 from datetime import datetime, timezone
+from decimal import Decimal
 import logging
 from typing import Dict, Optional
 
@@ -106,6 +107,23 @@ async def respond_to_provider_offer(
         """Respond with a modified `DemandBuilder` object to an offer coming from a provider."""
         raise NotImplementedError()
 
+    @abc.abstractmethod
+    async def invoice_accepted_amount(self, invoice: rest.payment.Invoice) -> Decimal:
+        """Return the amount we accept to pay for the invoice.
+
+        Current Golem Engine implementation accepts the invoice if returned amount is not lower than
+        `invoice.amount` and ignores the invoice otherwise. This will change in the future."""
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    async def debit_note_accepted_amount(self, debit_note: rest.payment.DebitNote) -> Decimal:
+        """Return the amount we accept to pay for the debit note.
+
+        Current Golem Engine implementation accepts the debit note if returned amount is not lower than
+        `debit_note.total_amount_due` and ignores the debit note otherwise.
+        This will change in the future."""
+        raise NotImplementedError()
+
 
 class MarketStrategy(BaseMarketStrategy, abc.ABC):
     """Abstract market strategy."""
@@ -207,3 +225,11 @@ async def respond_to_provider_offer(
 
     async def decorate_demand(self, demand: DemandBuilder) -> None:
         """Optionally add relevant constraints to a Demand."""
+
+    async def invoice_accepted_amount(self, invoice: rest.payment.Invoice) -> Decimal:
+        """Accept full invoice amount."""
+        return Decimal(invoice.amount)
+
+    async def debit_note_accepted_amount(self, debit_note: rest.payment.DebitNote) -> Decimal:
+        """Accept full debit note amount."""
+        return Decimal(debit_note.total_amount_due)

yapapi/strategy/wrapping_strategy.py

@@ -1,4 +1,5 @@
 import abc
+from decimal import Decimal
 
 from yapapi.props.builder import DemandBuilder
 from yapapi import rest
@@ -33,6 +34,12 @@ async def decorate_demand(self, demand: DemandBuilder) -> None:
     async def score_offer(self, offer: rest.market.OfferProposal) -> float:
         return await self.base_strategy.score_offer(offer)
 
+    async def invoice_accepted_amount(self, invoice: rest.payment.Invoice) -> Decimal:
+        return await self.base_strategy.invoice_accepted_amount(invoice)
+
+    async def debit_note_accepted_amount(self, debit_note: rest.payment.DebitNote) -> Decimal:
+        return await self.base_strategy.debit_note_accepted_amount(debit_note)
+
     async def respond_to_provider_offer(
         self,
         our_demand: DemandBuilder,