Costs - decimals instead of floats

Author: SergiiShcherbak

tests/test_all.py

@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 import os
+from decimal import Decimal
 from pathlib import Path
 from typing import Literal
 import warnings
@@ -245,11 +246,13 @@ def test_attr_models(self):
         with pytest.raises(ValueError):
             LLMPricing(input_per_1m_tokens=0.1)
         # LLM cost model
-        _LLMCost(input=0.01, output=0.02, total=0.03)
+        _LLMCost(input=Decimal("0.01"), output=Decimal("0.02"), total=Decimal("0.03"))
         with pytest.raises(ValueError):
-            _LLMCost(input=-0.01, output=0.02, total=0.03)
+            _LLMCost(
+                input=-Decimal("0.01"), output=Decimal("0.02"), total=Decimal("0.03")
+            )
         with pytest.raises(ValueError):
-            _LLMCost(input=-0.01)
+            _LLMCost(input=-Decimal("0.001"))
 
     def test_init_instance_bases(self):
         """
@@ -2481,6 +2484,6 @@ def test_total_cost_and_reset(self):
             assert usage_dict.usage.input == 0
             assert usage_dict.usage.output == 0
         for cost_dict in self.llm_group.get_cost() + self.llm_extractor_text.get_cost():
-            assert cost_dict.cost.input == 0
-            assert cost_dict.cost.output == 0
-            assert cost_dict.cost.total == 0
+            assert cost_dict.cost.input == Decimal("0.00000")
+            assert cost_dict.cost.output == Decimal("0.00000")
+            assert cost_dict.cost.total == Decimal("0.00000")

tests/utils.py

@@ -10,6 +10,7 @@
 import os
 import re
 from copy import deepcopy
+from decimal import Decimal, ROUND_HALF_UP
 from pathlib import Path
 import time
 from typing import Callable, Literal
@@ -227,9 +228,9 @@ def check_cost(llm: DocumentLLMGroup | DocumentLLM) -> None:
             assert hasattr(cost_item, "is_fallback")
             assert hasattr(cost_item, "cost") and cost_item.cost
             assert isinstance(cost_item.cost, _LLMCost)
-            if cost_item.cost.input > 0:
+            if cost_item.cost.input > Decimal("0.00000"):
                 cost_input_updated = True
-            if cost_item.cost.output > 0:
+            if cost_item.cost.output > Decimal("0.00000"):
                 cost_output_updated = True
         assert cost_input_updated and cost_output_updated
 
@@ -240,22 +241,25 @@ def output_test_costs(self) -> None:
         :return: None
         """
 
-        def get_cost_as_float(llm):
-            return round(sum([i.cost.total for i in llm.get_cost()]), 6)
+        def get_cost_as_decimal(llm):
+            # Sum all the total costs from each cost item starting from a Decimal zero.
+            total = sum((i.cost.total for i in llm.get_cost()), Decimal("0.00000"))
+            return total.quantize(Decimal("0.00001"), rounding=ROUND_HALF_UP)
 
-        total_cost_llm_group = get_cost_as_float(self.llm_group)
-        total_cost_llm = get_cost_as_float(self.llm_extractor_text)
-        total_cost_llm_with_fallback = get_cost_as_float(self.llm_with_fallback)
+        total_cost_llm_group = get_cost_as_decimal(self.llm_group)
+        total_cost_llm = get_cost_as_decimal(self.llm_extractor_text)
+        total_cost_llm_with_fallback = get_cost_as_decimal(self.llm_with_fallback)
         print("Cost of running tests (LLM 0 - group): ", total_cost_llm_group)
         print("Cost of running tests (LLM 1 - individual): ", total_cost_llm)
         print(
             "Cost of running tests (LLM with fallback): ", total_cost_llm_with_fallback
         )
+        total_cost = (
+            total_cost_llm_group + total_cost_llm + total_cost_llm_with_fallback
+        )
         print(
             "Total cost running tests: ",
-            round(
-                total_cost_llm_group + total_cost_llm + total_cost_llm_with_fallback, 6
-            ),
+            total_cost.quantize(Decimal("0.00001"), rounding=ROUND_HALF_UP),
         )
 
     @staticmethod

xdoc/internal/data_models.py

@@ -5,12 +5,13 @@
 """
 
 import time
+from decimal import Decimal
 from typing import Any, Optional
 
 from pydantic import BaseModel, Field, ConfigDict
-from pydantic import StrictFloat, StrictStr, StrictInt, StrictBool
+from pydantic import StrictStr, StrictInt, StrictBool
 
-from xdoc.internal.typings.aliases import NonEmptyStr, LLMRoleAny
+from xdoc.internal.typings.aliases import NonEmptyStr, LLMRoleAny, DefaultDecimalField
 
 
 class _LLMCall(BaseModel):
@@ -132,25 +133,16 @@ class _LLMCost(BaseModel):
     processing inputs, outputs, and the total processing cost.
 
     :ivar input: Cost associated with processing the input.
-    :type input: float
+    :type input: Decimal
     :ivar output: Cost associated with generating the output.
-    :type output: float
+    :type output: Decimal
     :ivar total: Total cost combining both input and output processing.
-    :type total: float
+    :type total: Decimal
     """
 
-    input: StrictFloat = Field(
-        default=0.0,
-        ge=0,
-    )
-    output: StrictFloat = Field(
-        default=0.0,
-        ge=0,
-    )
-    total: StrictFloat = Field(
-        default=0.0,
-        ge=0,
-    )
+    input: Decimal = DefaultDecimalField
+    output: Decimal = DefaultDecimalField
+    total: Decimal = DefaultDecimalField
 
     model_config = ConfigDict(extra="forbid", validate_assignment=True)
 

xdoc/internal/typings/aliases.py

@@ -4,9 +4,10 @@
 Internal module containing type aliases used throughout the framework.
 """
 
+from decimal import Decimal
 from typing import Annotated, Literal, Callable, Coroutine, Any
 
-from pydantic import StrictStr, StringConstraints
+from pydantic import StrictStr, StringConstraints, Field
 
 
 NonEmptyStr = Annotated[
@@ -44,3 +45,7 @@
 AsyncCalsAndKwargs = list[
     tuple[Callable[..., Coroutine[Any, Any, Any]], dict[str, Any]]
 ]
+
+DefaultDecimalField = Field(
+    default_factory=lambda: Decimal("0.00000"), ge=Decimal("0.00000")
+)

xdoc/public/llms.py

@@ -8,6 +8,7 @@
 
 import asyncio
 import warnings
+from decimal import Decimal, ROUND_HALF_UP
 from typing import TYPE_CHECKING, Optional, Any, Self
 
 from aiolimiter import AsyncLimiter
@@ -714,20 +715,29 @@ def _increment_cost(self, usage: _LLMUsage) -> None:
         """
 
         if self.pricing_details:
-            cost_input = (
-                usage.input / 1_000_000
-            ) * self.pricing_details.input_per_1m_tokens
-            cost_output = (
-                usage.output / 1_000_000
-            ) * self.pricing_details.output_per_1m_tokens
+            mil_dec = Decimal("1000000")
+            cost_input = (Decimal(str(usage.input)) / mil_dec) * Decimal(
+                str(self.pricing_details.input_per_1m_tokens)
+            )
+            cost_output = (Decimal(str(usage.output)) / mil_dec) * Decimal(
+                str(self.pricing_details.output_per_1m_tokens)
+            )
             cost_total = cost_input + cost_output
+
             self._cost.input += cost_input
             self._cost.output += cost_output
             self._cost.total += cost_total
-            round_cost = lambda x: round(x, 6)
-            self._cost.input = round_cost(self._cost.input)
-            self._cost.output = round_cost(self._cost.output)
-            self._cost.total = round_cost(self._cost.total)
+
+            round_dec = Decimal("0.00001")
+            self._cost.input = self._cost.input.quantize(
+                round_dec, rounding=ROUND_HALF_UP
+            )
+            self._cost.output = self._cost.output.quantize(
+                round_dec, rounding=ROUND_HALF_UP
+            )
+            self._cost.total = self._cost.total.quantize(
+                round_dec, rounding=ROUND_HALF_UP
+            )
 
     def _update_usage_and_cost(self, result: tuple[Any, _LLMUsage]) -> None:
         """