الأبحاث · جولةُ البرمجة الأولى
CB-2-01 — تتبّع خطأ وإصلاحه · Python · عالٍ
جولةُ البرمجة الأولى · 2026-10-09 · GAIBRA v2.30.03 · واجبُ التشغيل
| الترتيب | المتنافس | الرمز أمام المحكّم | الكلمات | الاختبارات | Opus | Grok | المجموع | الصدق (Opus · Grok) |
|---|---|---|---|---|---|---|---|---|
| 1 | Claude Sonnet | د | 1,577 | 12/12 | 95.0 | 100.0 | 97.5 | 12 · 12 |
| 2 | GAIBRA | أ | 1,580 | 12/12 | 89.0 | 94.0 | 91.5 | 7 · 11 |
| 3 | ChatGPT | ب | 706 | 12/12 | 87.0 | 83.0 | 85.0 | 10 · 9 |
| 4 | Gemini | ج | 556 | 12/12 | 71.0 | 73.0 | 72.0 | 4 · 7 |
| 5 | DeepSeek | هـ | 737 | 10/12 | 54.2 | 71.2 | 62.7 | 2 · 8 |
نصُّ السيناريو كما كتبه المولّد
اشتغل على نظام فوترة لمطاعم في الكويت، والعملة بالدينار الكويتي بثلاث خانات عشرية (1000 فلس = دينار واحد). سياسة العميل ثابتة ولا تقبل النقاش: كل سطر في الفاتورة يُقرَّب إلى أقرب فلس بنظام «النصف إلى الأعلى» (half-up).
المشكلة: على بعض الفواتير، مجموع الأسطر بعد التقريب لا يساوي إجمالي الفاتورة بفلس واحد، وتكاملنا مع برنامج المحاسبة عند العميل يرفض المستند بسبب عدم التطابق.
الكود الحالي (ملف invoicing.py كاملاً):
Python
from dataclasses import dataclass, field
TAX\_RATE = 0.15
@dataclass
class Line:
  name: str
  qty: int
  unit\_price: float
@dataclass
class Invoice:
  lines: list = field(default\_factory=list)
  discount: float = 0.0 # total discount in KWD
def round\_kwd(amount):
  return round(amount, 3)
def line\_total(line):
  return round\_kwd(line.qty \* line.unit\_price)
def compute\_invoice(inv):
  subtotal = sum(line\_total(l) for l in inv.lines)
  subtotal = round\_kwd(subtotal - inv.discount)
  tax = round\_kwd(subtotal \* TAX\_RATE)
  total = round\_kwd(subtotal + tax)
  return {"subtotal": subtotal, "tax": tax, "total": total}
الاختبار الذي يفشل عندنا في CI:
plain
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ test\_invoice\_matches\_erp \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
  inv = Invoice(lines=\[Line("برجر", 3, 2.885), Line("مشروب", 2, 1.475)], discount=0.0)
  result = compute\_invoice(inv)
> assert result\["total"] == sum(line\_total(l) for l in inv.lines) + result\["tax"]
E AssertionError: assert 11.771 == 11.772
جرّبت تغيير الترتيب (خصم قبل/بعد الضريبة) والنتيجة نفسها على فواتير أخرى.
المطلوب: تحديد السبب الجذري للمشكلة وتقديم ملف واحد مستقل معدَّل بحيث يكون إجمالي الفاتورة دائماً مساوياً لمجموع الأسطر المعروضة للعميل + الضريبة المحسوبة على ذلك الأساس، مع بقاء سياسة التقريب half-up لكل سطر على حدة.
القيود: Python 3.11، المكتبة القياسية فقط، سلوك حتمي، الحل لا يتجاوز 300 سطراً.
الردودُ الخمسة كما وصلت المحكّمين
أGAIBRA
الخلاصة
الجذر هو حساب المال بـ float ثمّ تقريبه بـ round(). القيمة 2.885 تُخزَّن أصغر قليلاً من حقيقتها، فيصير سطر البرجر 8.654 بدل 8.655، ويخسر الإجمالي فلساً واحداً.
لكنّ الرسالة 11.771 == 11.772 لا يمكن أن تصدر عن هذا الكود بهذه البيانات. ما يفشل في CI إمّا مُدخَلٌ آخر وإمّا نسخةٌ أخرى من الملف.
الإصلاح: Decimal مع ROUND\_HALF\_UP من حدود الإدخال إلى المُخرَج، وفحوصٌ تؤكّد قيمك داخل الملف.
تتبّعتُ الكود الأصليّ يدويّاً على فاتورتك نفسها، ولم أشغّل أيّ شيء.
القيمة 2.885 لا تُمثَّل في binary تمثيلاً دقيقاً. أقرب double إليها يقع تحتها بفارقٍ ضئيل. ضربُها في 3 يُعطي الـ double الأقرب إلى 8.655، وهو أيضاً تحت 8.655. الدالّة round(x, 3) في Python تقرّب القيمة الثنائيّة الفعليّة لا الرقم العشريّ الذي كتبتَه، فتُنتج 8.654.
سطر المشروب لا يتأثّر: 1.475 مخزَّنة فوق حقيقتها قليلاً، فيخرج السطر 2.95.
البند الكود الأصليّ (تتبّع يدويّ) ما تفرضه سياسة half-up
برجر 3 × 2.885 8.654 8.655
مشروب 2 × 1.475 2.95 2.950
مجموع الأسطر 11.604 11.605
الضريبة 1.741 1.741 (من 1.74075)
الإجمالي 13.345 13.346
الكود إذن يُخرج على هذه البيانات إجماليّاً يقارب 13.345، لا 11.771. الطرفان في اختبارك لا يختلفان إلّا بضجيج float، لأنّ الخصم صفر.
الفرق الحقيقيّ في هذه الفاتورة يظهر في مكانٍ آخر. أنت تعرض للعميل سطراً قيمته 8.655 عشريّاً، وتحسب الإجمالي على 8.654. وبرنامج المحاسبة عند العميل يحسب بالعشريّ، فيرى فرق الفلس ويرفض المستند.
أمّا الرقمان 11.771 و11.772 فلا أستطيع ربطهما بسببٍ محدّد من دون الفاتورة الفعليّة التي فشلت في CI. أقرب الاحتمالات ثلاثة: فاتورة أخرى غير التي في نصّ الاختبار، أو نسخة من invoicing.py بقيمة TAX\_RATE مختلفة، أو فاتورة فيها خصم.
مهمّ
اختبارك نفسه لا يتضمّن الخصم: يقارن total بمجموع الأسطر + الضريبة. أيّ فاتورة بخصمٍ قدره 0.001 تُنتج بالضبط فجوة فلسٍ واحد مثل التي رأيتها، والكود سليمٌ في هذه الجزئيّة. الثابت الصحيح هو: الإجمالي = مجموع الأسطر − الخصم + الضريبة.
الإصلاح
\# invoicing.py
"""Kuwaiti-dinar invoicing with per-line half-up rounding to the fils.
All money is Decimal. Floats are accepted only at the input boundary and are
read through their shortest repr ("2.885" stays 2.885), never through their
binary value. Run `python invoicing.py` to execute the self-checks.
"""
from \_\_future\_\_ import annotations
import unittest
from dataclasses import dataclass, field
from decimal import (
  ROUND\_DOWN,
  ROUND\_HALF\_UP,
  Context,
  Decimal,
  DivisionByZero,
  InvalidOperation,
  Overflow,
  localcontext,
)
from typing import Union
Number = Union\[Decimal, int, str, float]
FILS = Decimal("0.001")
ZERO\_KWD = Decimal("0.000")
TAX\_RATE = Decimal("0.15")
\_MONEY\_CONTEXT = Context(
  prec=28,
  rounding=ROUND\_HALF\_UP,
  traps=\[InvalidOperation, DivisionByZero, Overflow],
)
class InvoiceError(ValueError):
  """Raised when an invoice, a line or an amount violates input rules."""
def to\_decimal(value: Number, field\_name: str) -> Decimal:
  """Convert an input amount to a finite Decimal without binary noise.
  Raises InvoiceError for bool, unsupported types, unparsable text, NaN, infinity.
  """
  if isinstance(value, bool):
  raise InvoiceError(f"{field\_name}: bool is not a number")
  with localcontext(\_MONEY\_CONTEXT):
  try:
  if isinstance(value, Decimal):
  result = value
  elif isinstance(value, int):
  result = Decimal(value)
  elif isinstance(value, float):
  result = Decimal(repr(value))
  elif isinstance(value, str):
  result = Decimal(value.strip())
  else:
  raise InvoiceError(
  f"{field\_name}: unsupported type {type(value).\_\_name\_\_}"
  )
  except InvalidOperation as exc:
  raise InvoiceError(f"{field\_name}: not a number: {value!r}") from exc
  if not result.is\_finite():
  raise InvoiceError(f"{field\_name}: must be finite, got {value!r}")
  return result
def round\_kwd(amount: Number) -> Decimal:
  """Round an amount to the nearest fils; exact ties go up (half-up)."""
  with localcontext(\_MONEY\_CONTEXT):
  return to\_decimal(amount, "amount").quantize(FILS, rounding=ROUND\_HALF\_UP)
def \_validate\_line\_fields(name: object, qty: object) -> None:
  """Reject empty names and non-positive or non-integer quantities."""
  if not isinstance(name, str) or not name.strip():
  raise InvoiceError("line name must be a non-empty string")
  if isinstance(qty, bool) or not isinstance(qty, int) or qty < 1:
  raise InvoiceError(f"line qty must be a positive integer, got {qty!r}")
def \_validated\_unit\_price(value: Number) -> Decimal:
  """Return the unit price as a non-negative finite Decimal."""
  price = to\_decimal(value, "unit\_price")
  if price < 0:
  raise InvoiceError(f"unit\_price must not be negative, got {value!r}")
  return price
def \_validated\_discount(value: Number) -> Decimal:
  """Return the discount as a non-negative Decimal rounded half-up to the fils."""
  discount = to\_decimal(value, "discount")
  if discount < 0:
  raise InvoiceError(f"discount must not be negative, got {value!r}")
  return round\_kwd(discount)
@dataclass
class Line:
  """One invoice line; unit\_price is normalised to Decimal on construction."""
  name: str
  qty: int
  unit\_price: Number
  def \_\_post\_init\_\_(self) -> None:
  \_validate\_line\_fields(self.name, self.qty)
  self.unit\_price = \_validated\_unit\_price(self.unit\_price)
@dataclass
class Invoice:
  """An invoice; discount is a total amount in KWD, normalised to Decimal."""
  lines: list\[Line] = field(default\_factory=list)
  discount: Number = ZERO\_KWD
  def \_\_post\_init\_\_(self) -> None:
  if not isinstance(self.lines, list) or not all(
  isinstance(item, Line) for item in self.lines
  ):
  raise InvoiceError("lines must be a list of Line")
  self.discount = \_validated\_discount(self.discount)
def line\_total(line: Line) -> Decimal:
  """Return qty x unit\_price rounded half-up to the fils (the displayed amount)."""
  if not isinstance(line, Line):
  raise InvoiceError(f"expected Line, got {type(line).\_\_name\_\_}")
  \_validate\_line\_fields(line.name, line.qty)
  price = \_validated\_unit\_price(line.unit\_price)
  with localcontext(\_MONEY\_CONTEXT):
  return round\_kwd(price \* line.qty)
def compute\_invoice(inv: Invoice) -> dict\[str, object]:
  """Compute an invoice whose total equals displayed lines - discount + tax.
  Returns Decimal amounts: subtotal (after discount), tax, total, plus
  line\_totals, lines\_total and the applied discount for the ERP payload.
  Raises InvoiceError if the discount exceeds the sum of the lines.
  """
  if not isinstance(inv, Invoice):
  raise InvoiceError(f"expected Invoice, got {type(inv).\_\_name\_\_}")
  line\_totals = \[line\_total(line) for line in inv.lines]
  with localcontext(\_MONEY\_CONTEXT):
  lines\_total = sum(line\_totals, ZERO\_KWD)
  discount = \_validated\_discount(inv.discount)
  if discount > lines\_total:
  raise InvoiceError(
  f"discount {discount} exceeds lines total {lines\_total}"
  )
  subtotal = lines\_total - discount
  tax = round\_kwd(subtotal \* TAX\_RATE)
  total = subtotal + tax
  return {
  "subtotal": subtotal,
  "tax": tax,
  "total": total,
  "line\_totals": line\_totals,
  "lines\_total": lines\_total,
  "discount": discount,
  }
def \_user\_invoice(discount: Number = 0.0) -> Invoice:
  return Invoice(
  lines=\[Line("برجر", 3, 2.885), Line("مشروب", 2, 1.475)], discount=discount
  )
class InvoiceSelfCheck(unittest.TestCase):
  """Executable assertions of the values traced by hand in the reply."""
  def test\_invoice\_matches\_erp(self) -> None:
  inv = \_user\_invoice()
  result = compute\_invoice(inv)
  self.assertEqual(
  result\["total"], sum(line\_total(l) for l in inv.lines) + result\["tax"]
  )
  def test\_user\_invoice\_line\_totals\_are\_half\_up(self) -> None:
  result = compute\_invoice(\_user\_invoice())
  self.assertEqual(result\["line\_totals"], \[Decimal("8.655"), Decimal("2.950")])
  def test\_user\_invoice\_totals(self) -> None:
  result = compute\_invoice(\_user\_invoice())
  self.assertEqual(result\["subtotal"], Decimal("11.605"))
  self.assertEqual(result\["tax"], Decimal("1.741"))
  self.assertEqual(result\["total"], Decimal("13.346"))
  def test\_discount\_keeps\_total\_balanced(self) -> None:
  result = compute\_invoice(\_user\_invoice(discount="0.5"))
  self.assertEqual(result\["subtotal"], Decimal("11.105"))
  self.assertEqual(result\["tax"], Decimal("1.666"))
  self.assertEqual(result\["total"], Decimal("12.771"))
  self.assertEqual(
  result\["total"],
  sum(result\["line\_totals"], ZERO\_KWD) - result\["discount"] + result\["tax"],
  )
  def test\_exact\_tie\_rounds\_up\_not\_to\_even(self) -> None:
  self.assertEqual(line\_total(Line("x", 1, "1.0005")), Decimal("1.001"))
  def test\_result\_independent\_of\_caller\_decimal\_context(self) -> None:
  with localcontext() as ctx:
  ctx.prec = 3
  ctx.rounding = ROUND\_DOWN
  result = compute\_invoice(\_user\_invoice())
  self.assertEqual(result\["total"], Decimal("13.346"))
  def test\_rejects\_invalid\_inputs(self) -> None:
  with self.assertRaises(InvoiceError):
  Line("x", 0, "1.000")
  with self.assertRaises(InvoiceError):
  Line("x", 1, "-1")
  with self.assertRaises(InvoiceError):
  Line("x", 1, float("nan"))
  with self.assertRaises(InvoiceError):
  compute\_invoice(\_user\_invoice(discount="20"))
if \_\_name\_\_ == "\_\_main\_\_":
  unittest.main()
التحقّق يتمّ بأمرٍ واحد: python invoicing.py. القيم المثبّتة في الاختبارات هي نتائج تتبّعي اليدويّ، والاختبار الذي يفشل عندك في CI موجودٌ فيها باسمه.
هذه كلّ فروق السلوك عن الأصل:
نوع القيم المُعادة: صارت كلّها Decimal بدل float.
مفاتيح جديدة في الناتج: line\_totals وlines\_total وdiscount.
نتيجة فاتورتك نفسها: تتغيّر من 13.345 إلى 13.346، ومن 8.654 إلى 8.655 في سطر البرجر.
التقريب: الأنصاف الدقيقة تُقرَّب إلى الأعلى دائماً، لا إلى الزوجيّ.
التحويل: unit\_price وdiscount يتحوّلان إلى Decimal عند إنشاء الكائن، وأيّ float يُقرأ عبر repr.
الخصم: يُقرَّب half-up إلى الفلس قبل طرحه. أمّا الأصل فكان يقرّب ناتج الطرح بـ round().
مدخلات صارت مرفوضة: الكمّيّة صفرٌ أو سالبةٌ أو bool، والسعر السالب، وNaN واللانهاية، والاسم الفارغ، والنصوص غير الرقميّة، والخصم السالب، والخصم الأكبر من مجموع الأسطر. كلّها ترمي InvoiceError، وهي فرعٌ من ValueError.
تشغيل الملف مباشرةً: صار ينفّذ الاختبارات.
شرح السبب
العيب ليس في ترتيب الخصم والضريبة، ولذلك لم يُفِد تبديلُه.
العيب في نوع البيانات. float يحمل كسراً ثنائيّاً، والسياسة عشريّة. كلّ قيمةٍ تنتهي عند الحدّ الفاصل، مثل الفلس الأخير في 8.655، يُحسم تقريبُها بحسب موقعها الثنائيّ، وهذا الموقع قد يقع تحت الحدّ أو فوقه. هذا هو التقريب الأوّل الذي يخون السياسة.
وهناك خيانةٌ ثانية حتّى حين تكون القيمة دقيقة: round() تتّبع قاعدة half-to-even، وهي ليست half-up.
لهذا العيب طابعٌ نظاميّ. كلّ موضعٍ آخر في النظام يحسب المال بـ float يحمل الخطر نفسه: التقارير، والمرتجعات، والتصدير إلى برنامج المحاسبة.
الإصلاح آمنٌ تحت التزامن. localcontext محلّيٌّ لكلّ thread، والكائنات لا تتشارك حالةً قابلةً للتعديل. والناتج لا يتأثّر بأيّ context عشريّ يضبطه المستدعي، وهذا ما يغطّيه أحد الاختبارات.
الوقاية
امنع float في أيّ حقلٍ ماليّ عند حدود النظام. مرّر المبالغ نصوصاً أو Decimal من قاعدة البيانات ومن واجهة الـ POS.
صحّح كذلك ثابت اختبارك ليتضمّن الخصم، وأضِف اختبار خصائص بمولّد random ذي بذرةٍ ثابتة. هذا الاختبار يولّد فواتير كثيرة ويؤكّد عليها جميعاً أنّ الإجمالي يساوي مجموع الأسطر − الخصم + الضريبة. وأيّ عودةٍ إلى float ستكسر هذا الثابت عند أوّل قيمةٍ على الحدّ.
قراري أن تعتمد هذا الملف الآن. ولكي أحسم مصدر 11.771 تحديداً: ما الأسطر والخصم وقيمة TAX\_RATE في الفاتورة التي فشلت فعلاً في CI؟ إن أرسلتها هنا تتبّعتُها سطراً سطراً، وتبيّن إن كانت فجوة الفلس من الخصم أم من نسخةٍ أخرى من الملف.
🏃 لم يُشغَّل — السبب: Docker غيرُ متاح: docker: An error occurred trying to start process 'docker' with working directory 'D:\\Sites\\gaibra.ai'. The system cannot find the file specified.
ما لا أعرفه: تصنيفُ السبب الجذريّ لهذا الخطأ بعينه
دClaude Sonnet
Working through a floating-point rounding puzzle.
سأعيد إنتاج الفشل أولاً لأحدد السبب بدقة، ثم أكتب الملف المعدَّل وأختبره.
Created a file, shared a file, ran 3 commands
السبب الجذري
ترتيب الخصم والضريبة ليس سبب المشكلة. السبب هو تمثيل المال بـ float واستخدام round()، وهذا ينتج ثلاثة أخطاء متراكبة:
round() في بايثون ليس half-up. هو تقريب «النصف إلى الزوجي» (banker’s rounding). مثلاً round(2.5) يعطي 2.
الـ float لا يمثّل الفلس بدقة. القيمة 2.885 مخزَّنة فعلياً كـ 2.884999999…، و1.475 مخزَّنة كـ 1.475000…09. لذلك تقع القيم المنتهية بـ 5 أحياناً تحت نقطة المنتصف وأحياناً فوقها بشكل غير متوقع. جرّبت كل حالات المنتصف من 0.0005 إلى 9.9995، وكان round\_kwd مخالفاً لسياسة half-up في نصفها تماماً. مثال: 0.0045 تصبح 0.004 بدلاً من 0.005.
الجمع والمقارنة بـ float. المجموع sum(...) + tax لا يطابق بالضرورة بتاً ببت نتيجة round(subtotal + tax, 3). على 20,000 فاتورة عشوائية بالكود الحالي، فشل شرط الاختبار في 5,343 منها.
ملاحظة مهمة: المدخلات المكتوبة في الاختبار (3 × 2.885 و2 × 1.475) تنجح فعلياً عندي بالكود القديم، والإجمالي 13.346. أما القيم 11.771 و11.772 في السجل فلا تنتج عن هذه الأسطر. على الأرجح السجل منسوخ من تشغيل لفاتورة أخرى، فيستحق أن تراجع أي فاتورة فشلت فعلاً في CI.
الإصلاح
المدخلات تُحوَّل إلى Decimal من نصّها، فيصبح 2.885 هو 2.885 بالضبط. الـ float مقبول ويُحوَّل عبر repr.
كل سطر يُقرَّب منفرداً بـ ROUND\_HALF\_UP ويُخزَّن كعدد صحيح من الفلوس.
ما بعد ذلك كله جمع وطرح أعداد صحيحة، فلا انحراف ممكن:
subtotal = مجموع الأسطر − الخصم
tax = half\_up(subtotal × 0.15) مرة واحدة
total = subtotal + tax
التطابق مضمون بالبناء نفسه، وعليه assert داخلي احتياطاً.
للتصدير إلى برنامج المحاسبة استخدم as\_dict(). هي تُرجع نصوصاً بثلاث خانات بالضبط ("13.346")، فلا يدخل float في الـ JSON أبداً.
result\["total"] ما زال يعمل للتوافق مع الكود القديم، لكنه يُرجع Decimal الآن.
اختبرت الملف على حالة الـ CI، وعلى حالات half-up الحدّية، وعلى 50,000 فاتورة عشوائية فيها خصومات، ونجحت كلها.
اختبار CI يحتاج تعديلاً صغيراً إذا كانت الفاتورة فيها خصم، لأنه لا يطرح الخصم حالياً:
result.total == sum(line\_total(l) for l in inv.lines) - result.discount + result.tax
Invoicing · PY
"""
Invoicing for Kuwaiti restaurants (KWD, 3 decimals: 1 KWD = 1000 fils).
 
Policy: every invoice line is rounded to the nearest fils, half-up,
independently. Invoice total is ALWAYS exactly:
 
  sum(displayed line totals) - discount + tax
 
where tax is computed (and rounded half-up once) on that same basis.
 
Root cause of the old mismatches:
  1. Money was stored as binary float. 2.885 is really 2.88499999999999978...,
  so "x.xxx5" values sit just below or above the midpoint unpredictably.
  2. Python's round() is round-half-EVEN (banker's rounding), not half-up,
  and it operates on that inexact binary value.
  3. Totals were compared/added as floats, so 11.605 + 1.741 may not equal
  the float produced by round(11.605 + 1.741, 3) bit for bit.
 
Fix: parse inputs as Decimal from their text form, round with ROUND\_HALF\_UP,
and keep every amount as an integer number of fils from that point on.
Integer addition is exact, so the invariant holds by construction.
 
Python 3.11, standard library only, deterministic.
"""
from \_\_future\_\_ import annotations
 
from dataclasses import dataclass, field
from decimal import ROUND\_HALF\_UP, Decimal, InvalidOperation, localcontext
 
TAX\_RATE = Decimal("0.15")
FILS\_PER\_KWD = 1000
\_FILS = Decimal("0.001")
 
Number = Decimal | int | str | float
 
 
def to\_decimal(value: Number) -> Decimal:
  """Convert input to an exact Decimal.
 
  Floats go through repr() so 2.885 becomes Decimal('2.885') (what the user
  typed), not Decimal(2.88499999999999978...). Prefer passing str/Decimal.
  """
  if isinstance(value, bool):
  raise TypeError("bool is not a money amount")
  if isinstance(value, Decimal):
  d = value
  elif isinstance(value, int):
  d = Decimal(value)
  elif isinstance(value, float):
  d = Decimal(repr(value))
  elif isinstance(value, str):
  try:
  d = Decimal(value.strip())
  except InvalidOperation as exc:
  raise ValueError(f"invalid amount: {value!r}") from exc
  else:
  raise TypeError(f"unsupported amount type: {type(value).\_\_name\_\_}")
  if not d.is\_finite():
  raise ValueError(f"amount must be finite: {value!r}")
  return d
 
 
def round\_half\_up\_fils(amount: Number) -> int:
  """Round an amount in KWD to the nearest fils (half-up), return int fils.
 
  Half-up here means ties go away from zero (Decimal.ROUND\_HALF\_UP), so
  0.0125 -> 13 fils and -0.0125 -> -13 fils.
  """
  with localcontext() as ctx:
  ctx.prec = 50 # wide enough that multiplication never loses digits
  q = to\_decimal(amount).quantize(\_FILS, rounding=ROUND\_HALF\_UP)
  return int(q \* FILS\_PER\_KWD)
 
 
def fils\_to\_kwd(fils: int) -> Decimal:
  """Integer fils -> Decimal KWD with exactly 3 decimals (e.g. 13346 -> 13.346)."""
  return (Decimal(fils) / FILS\_PER\_KWD).quantize(\_FILS)
 
 
def kwd\_str(fils: int) -> str:
  return f"{fils\_to\_kwd(fils):.3f}"
 
 
@dataclass
class Line:
  name: str
  qty: int
  unit\_price: Number # KWD; str or Decimal recommended, float accepted
 
  def \_\_post\_init\_\_(self) -> None:
  if isinstance(self.qty, bool) or not isinstance(self.qty, int):
  raise TypeError("qty must be an int")
  if self.qty < 0:
  raise ValueError("qty must be >= 0")
  self.unit\_price = to\_decimal(self.unit\_price)
  if self.unit\_price < 0:
  raise ValueError("unit\_price must be >= 0")
 
 
@dataclass
class Invoice:
  lines: list\[Line] = field(default\_factory=list)
  discount: Number = Decimal("0") # total discount in KWD
 
  def \_\_post\_init\_\_(self) -> None:
  self.discount = to\_decimal(self.discount)
  if self.discount < 0:
  raise ValueError("discount must be >= 0")
 
 
def line\_total\_fils(line: Line) -> int:
  """Line total in fils, rounded half-up per line (client policy)."""
  with localcontext() as ctx:
  ctx.prec = 50
  return round\_half\_up\_fils(line.unit\_price \* line.qty)
 
 
def line\_total(line: Line) -> Decimal:
  """Line total as displayed to the customer (Decimal KWD, 3 places)."""
  return fils\_to\_kwd(line\_total\_fils(line))
 
 
@dataclass(frozen=True)
class InvoiceResult:
  line\_totals\_fils: tuple\[int, ...]
  lines\_sum\_fils: int
  discount\_fils: int
  subtotal\_fils: int # lines\_sum - discount; the tax basis
  tax\_fils: int
  total\_fils: int
 
  # Decimal views for display / ERP export
  @property
  def subtotal(self) -> Decimal:
  return fils\_to\_kwd(self.subtotal\_fils)
 
  @property
  def tax(self) -> Decimal:
  return fils\_to\_kwd(self.tax\_fils)
 
  @property
  def total(self) -> Decimal:
  return fils\_to\_kwd(self.total\_fils)
 
  @property
  def discount(self) -> Decimal:
  return fils\_to\_kwd(self.discount\_fils)
 
  @property
  def lines\_sum(self) -> Decimal:
  return fils\_to\_kwd(self.lines\_sum\_fils)
 
  def \_\_getitem\_\_(self, key: str) -> Decimal:
  """Backward compatibility: result\["total"], result\["tax"], ..."""
  if key in ("subtotal", "tax", "total", "discount", "lines\_sum"):
  return getattr(self, key)
  raise KeyError(key)
 
  def as\_dict(self) -> dict\[str, str]:
  """String amounts with exactly 3 decimals - safe to serialize to the ERP."""
  return {
  "lines": \[kwd\_str(f) for f in self.line\_totals\_fils],
  "lines\_sum": kwd\_str(self.lines\_sum\_fils),
  "discount": kwd\_str(self.discount\_fils),
  "subtotal": kwd\_str(self.subtotal\_fils),
  "tax": kwd\_str(self.tax\_fils),
  "total": kwd\_str(self.total\_fils),
  }
 
 
def compute\_invoice(inv: Invoice, tax\_rate: Number = TAX\_RATE) -> InvoiceResult:
  rate = to\_decimal(tax\_rate)
  if rate < 0:
  raise ValueError("tax\_rate must be >= 0")
 
  # 1. Each line rounded half-up on its own -> these are the displayed values.
  line\_fils = tuple(line\_total\_fils(l) for l in inv.lines)
 
  # 2. Everything below is integer fils arithmetic: exact, no drift.
  lines\_sum = sum(line\_fils)
  discount = round\_half\_up\_fils(inv.discount)
  if discount > lines\_sum:
  raise ValueError("discount exceeds invoice lines total")
  subtotal = lines\_sum - discount
 
  # 3. Tax on the displayed basis, rounded half-up once.
  with localcontext() as ctx:
  ctx.prec = 50
  tax = round\_half\_up\_fils(fils\_to\_kwd(subtotal) \* rate)
 
  total = subtotal + tax
 
  result = InvoiceResult(line\_fils, lines\_sum, discount, subtotal, tax, total)
  # Invariant the ERP checks - holds by construction, asserted for safety.
  assert result.total\_fils == sum(line\_fils) - discount + tax
  return result
 
 
\# --------------------------------------------------------------------------
\# Self-test: python invoicing.py
\# --------------------------------------------------------------------------
def \_self\_test() -> None:
  import random
 
  # The CI case.
  inv = Invoice(lines=\[Line("برجر", 3, "2.885"), Line("مشروب", 2, "1.475")])
  r = compute\_invoice(inv)
  assert r.total == sum(line\_total(l) for l in inv.lines) + r.tax
  assert r.as\_dict() == {
  "lines": \["8.655", "2.950"], "lines\_sum": "11.605", "discount": "0.000",
  "subtotal": "11.605", "tax": "1.741", "total": "13.346",
  }, r.as\_dict()
 
  # Floats are accepted and give the same answer as strings.
  inv\_f = Invoice(lines=\[Line("برجر", 3, 2.885), Line("مشروب", 2, 1.475)])
  assert compute\_invoice(inv\_f) == r
 
  # Half-up, not half-even (round() gave the wrong answers here).
  assert line\_total\_fils(Line("x", 1, "0.0125")) == 13
  assert line\_total\_fils(Line("x", 1, "0.0145")) == 15
  assert line\_total\_fils(Line("x", 1, "1.0005")) == 1001
  assert line\_total\_fils(Line("x", 1, "2.6745")) == 2675
  assert line\_total\_fils(Line("x", 3, "0.3335")) == 1001 # 1.0005 -> 1.001
 
  # Discount: total = lines - discount + tax on (lines - discount).
  inv\_d = Invoice(lines=\[Line("x", 2, "1.2345")], discount="0.500")
  rd = compute\_invoice(inv\_d)
  assert rd.as\_dict()\["lines"] == \["2.469"]
  assert rd.subtotal\_fils == 1969
  assert rd.tax\_fils == 295 # 1.969 \* 0.15 = 0.29535 -> 0.295
  assert rd.total\_fils == 2264
 
  # Randomized invariant check (fixed seed => deterministic).
  rng = random.Random(20261009)
  for \_ in range(50\_000):
  lines = \[
  Line("x", rng.randint(0, 20), f"{rng.randint(0, 99\_999) / 10\_000:.4f}")
  for \_ in range(rng.randint(1, 6))
  ]
  ls = sum(line\_total\_fils(l) for l in lines)
  disc = f"{rng.randint(0, ls) / 1000:.3f}"
  res = compute\_invoice(Invoice(lines, disc))
  assert res.total == (
  sum(line\_total(l) for l in lines) - res.discount + res.tax
  )
  assert res.total\_fils == ls - res.discount\_fils + res.tax\_fils
 
  print("all invoicing checks passed")
 
 
if \_\_name\_\_ == "\_\_main\_\_":
  \_self\_test()
 
بChatGPT
السبب الجذري ليس ترتيب تطبيق الخصم والضريبة، بل استخدام float مع الدالة round() الافتراضية في Python، التي تستخدم التقريب إلى الزوجي عند التعادل (round half to even)، وليس التقريب المطلوب half-up. كما أن الأعداد العشرية مثل 2.885 لا تُمثَّل بدقة باستخدام float، مما قد يغيّر نتيجة التقريب.
هناك نقطة ثانية مهمة: يجب أن تُحسب الضريبة على مجموع الأسطر بعد تقريب كل سطر إلى أقرب فلس، وبعد خصم الخصم وفق سياسة واضحة، ثم يُقرَّب إجمالي الضريبة إلى أقرب فلس. وأخيرًا، يُحسب الإجمالي بجمع المبالغ النهائية المقربة، لا بإعادة حسابه من قيم غير مقربة.
الحل الأنسب هو استخدام Decimal من المكتبة القياسية، مع ROUND\_HALF\_UP، وتمثيل الدينار بثلاث خانات عشرية في كل المبالغ النقدية النهائية.
الملف المعدّل: invoicing.py
كتابة
from dataclasses import dataclass, field
from decimal import Decimal, ROUND\_HALF\_UP, InvalidOperation
from typing import Sequence
\# Kuwait: 1 KWD = 1000 fils
MONEY\_QUANTUM = Decimal("0.001")
TAX\_RATE = Decimal("0.15")
ZERO = Decimal("0.000")
def to\_decimal(value: Decimal | int | float | str) -> Decimal:
  """Convert a number to Decimal without importing binary float artifacts."""
  if isinstance(value, bool):
  raise TypeError("Boolean values are not valid monetary amounts")
  if isinstance(value, float):
  value = str(value)
  try:
  result = Decimal(value)
  except (InvalidOperation, ValueError, TypeError) as exc:
  raise ValueError(f"Invalid monetary amount: {value!r}") from exc
  if not result.is\_finite():
  raise ValueError("Monetary amounts must be finite")
  return result
def round\_kwd(amount: Decimal | int | float | str) -> Decimal:
  """Round a KWD amount to the nearest fils, using half-up."""
  return to\_decimal(amount).quantize(
  MONEY\_QUANTUM,
  rounding=ROUND\_HALF\_UP,
  )
@dataclass(frozen=True)
class Line:
  name: str
  qty: int
  unit\_price: Decimal | int | float | str
  def \_\_post\_init\_\_(self) -> None:
  if isinstance(self.qty, bool) or not isinstance(self.qty, int):
  raise TypeError("Quantity must be an integer")
  if self.qty < 0:
  raise ValueError("Quantity cannot be negative")
  # Normalize floats through their decimal string representation.
  object.\_\_setattr\_\_(self, "unit\_price", to\_decimal(self.unit\_price))
  if self.unit\_price < 0:
  raise ValueError("Unit price cannot be negative")
@dataclass
class Invoice:
  lines: list\[Line] = field(default\_factory=list)
  discount: Decimal | int | float | str = ZERO
  def \_\_post\_init\_\_(self) -> None:
  self.discount = round\_kwd(self.discount)
  if self.discount < ZERO:
  raise ValueError("Discount cannot be negative")
def line\_total(line: Line) -> Decimal:
  """Calculate and round each invoice line independently."""
  return round\_kwd(Decimal(line.qty) \* line.unit\_price)
def compute\_invoice(inv: Invoice) -> dict:
  # These are the exact amounts displayed for individual invoice lines.
  line\_totals = \[line\_total(line) for line in inv.lines]
  gross\_subtotal = sum(line\_totals, ZERO)
  # Preserve the existing behavior: discount is deducted before tax.
  if inv.discount > gross\_subtotal:
  raise ValueError("Discount cannot exceed the line subtotal")
  subtotal = round\_kwd(gross\_subtotal - inv.discount)
  tax = round\_kwd(subtotal \* TAX\_RATE)
  # Add already-rounded monetary amounts; do not recalculate from floats.
  total = subtotal + tax
  # Enforce the accounting invariant explicitly.
  if total != subtotal + tax:
  raise ArithmeticError("Invoice total does not reconcile")
  return {
  "line\_totals": line\_totals,
  "gross\_subtotal": gross\_subtotal,
  "discount": inv.discount,
  "subtotal": subtotal,
  "tax": tax,
  "total": total,
  }
اختبار الحالة المذكورة
from decimal import Decimal
inv = Invoice(
  lines=\[
  Line("برجر", 3, 2.885),
  Line("مشروب", 2, 1.475),
  ],
  discount=0,
)
result = compute\_invoice(inv)
assert result\["line\_totals"] == \[
  Decimal("8.655"),
  Decimal("2.950"),
]
assert result\["gross\_subtotal"] == Decimal("11.605")
assert result\["subtotal"] == Decimal("11.605")
assert result\["tax"] == Decimal("1.741")
assert result\["total"] == Decimal("13.346")
assert result\["total"] == sum(
  result\["line\_totals"], Decimal("0.000")
) + result\["tax"]
print(result)
لماذا هذا الحل صحيح؟
تقريب نصف فلس إلى الأعلى: ROUND\_HALF\_UP يحقق سياسة العميل بدل round() الافتراضية.
لا توجد أخطاء تمثيل ثنائي: تُحوّل قيم float عبر str()، وتُستخدم Decimal في العمليات المالية.
تقريب كل سطر مستقل: يُقرَّب ناتج الكمية × سعر الوحدة إلى ثلاثة منازل عشرية قبل جمع الأسطر.
اتساق الإجمالي: يُحسب الإجمالي من المجموع الخاضع للضريبة بعد الخصم، مضافًا إليه مبلغ الضريبة المقرب.
تنبيه مهم بشأن الخصم: في وجود خصم، يصبح الإجمالي مساويًا لمجموع الأسطر ناقص الخصم، زائد الضريبة. إذا كان نظام المحاسبة يشترط حرفيًا أن يساوي الإجمالي مجموع الأسطر المعروضة زائد الضريبة، فيجب إظهار الخصم كسطر سالب ضمن الفاتورة بدل خصمه خارج الأسطر.
كذلك، الأرقام 11.771 و11.772 في رسالة الاختبار لا تتوافق مع بيانات المثال المعروضة؛ فالحساب وفق سياسة التقريب المذكورة يعطي إجماليًا قدره 13.346 دينار كويتي.
هـDeepSeek
تحليل المشكلة
السبب الجذري
المشكلة ليست في round\_kwd نفسها، بل في الافتراض الخاطئ بأن جمع الأعداد المُقرَّبة يساوي تقريب المجموع.
عندك سطران:
السطر الحساب الخام التقريب half-up
برجر 3 × 2.885 = 8.655 8.655 (لا تغيير)
مشروب 2 × 1.475 = 2.950 2.950 (لا تغيير)
المجموع 11.605 11.605
الضريبة على 11.605:
11.605 × 0.15 = 1.74075
round(1.74075, 3) = 1.741 (لأن round في Python يستخدم banker's rounding، لكن هنا الرقم واضح)
الإجمالي الحالي: round(11.605 + 1.741) = round(13.346) = 13.346
لكن اختبارك يقول 11.771 مقابل 11.772 — إذن هناك خصم أو أرقام مختلفة عمّا حسبته يدوياً. المهم أن الفارق فلس واحد وهو ناتج حتمي عن:
round() في Python تستخدم banker's rounding (round-half-to-even)، وليست half-up كما تظن. مثلاً round(2.5) تعطي 2 وليس 3.
الضريبة تُحسب على subtotal بعد تقريبه، ثم تُقرَّب من جديد، ثم total يُقرَّب مرة ثالثة — ثلاث عمليات تقريب متتالية كل واحدة قد تُدخل انحرافاً بمقدار فلس.
اختبارك يقارن total مع sum(line\_total) + tax، لكن total محسوب من round(subtotal + tax) وsubtotal نفسه مجموع أسطر مُقرَّبة — فلا يوجد ضمان رياضي أن round(a+b) == round(a) + round(b).
الخلاصة: التقريب المتسلسل (line → subtotal → discount → tax → total) يخلق انحرافات متراكمة، وسياسة العميل تفرض أن total == sum(lines) + tax بالضبط.
الحل
القاعدة الذهبية: احسب الإجمالي من الأسطر المعروضة مباشرة، واعتبر الضريبة مشتقة منه، لا العكس.
subtotal = مجموع الأسطر المُقرَّبة (هذا ما يراه العميل).
discount يُقرَّب ويُطرح من subtotal بعد التقريب.
taxable\_base = subtotal - discount.
tax = half\_up(taxable\_base × 0.15).
total = taxable\_base + tax (بدون تقريب إضافي — هو أصلاً مجموع أرقام بثلاث خانات).
بهذا يتحقق الشرط دائماً: total == (sum(lines) - discount) + tax، والفرق بين الطرفين صفر رياضياً.
الملف المعدَّل (مستقل، stdlib فقط، أقل من 300 سطر)
python
"""
invoicing.py — نظام فوترة مطاعم بالدينار الكويتي (3 خانات عشرية).
سياسة التقريب: half-up لكل سطر على حدة، وإجمالي الفاتورة يُشتق
من الأسطر المعروضة + الضريبة، لضمان تطابق دائم مع برنامج المحاسبة.
"""
from dataclasses import dataclass, field
from decimal import Decimal, ROUND\_HALF\_UP, getcontext
\# دقة كافية لتفادي أي فقدان في العمليات الوسيطة
getcontext().prec = 28
TAX\_RATE = Decimal("0.15")
Q = Decimal("0.001") # 3 خانات عشرية = فلس واحد
def half\_up(value) -> Decimal:
  """تقريب half-up إلى 3 خانات عشرية (أقرب فلس، والنصف للأعلى)."""
  d = Decimal(str(value))
  return d.quantize(Q, rounding=ROUND\_HALF\_UP)
@dataclass
class Line:
  name: str
  qty: int
  unit\_price: float
  @property
  def total(self) -> Decimal:
  # qty صحيح، unit\_price يُحوَّل عبر str لتفادي أخطاء float الثنائية
  return half\_up(Decimal(self.qty) \* Decimal(str(self.unit\_price)))
@dataclass
class Invoice:
  lines: list = field(default\_factory=list)
  discount: float = 0.0 # خصم إجمالي بالدينار
def line\_total(line: Line) -> Decimal:
  return line.total
def compute\_invoice(inv: Invoice) -> dict:
  # 1) مجموع الأسطر بعد تقريب كل سطر على حدة (ما يراه العميل)
  subtotal = sum((l.total for l in inv.lines), Decimal("0.000"))
  # 2) الخصم يُقرَّب half-up ثم يُطرح من المجموع المعروض
  discount = half\_up(inv.discount)
  taxable\_base = half\_up(subtotal - discount)
  # 3) الضريبة على الأساس الخاضع بعد التقريب
  tax = half\_up(taxable\_base \* TAX\_RATE)
  # 4) الإجمالي = الأساس + الضريبة (بدون تقريب إضافي)
  # هذا يضمن رياضياً: total == (subtotal - discount) + tax
  total = half\_up(taxable\_base + tax)
  return {
  "subtotal": float(taxable\_base),
  "discount": float(discount),
  "tax": float(tax),
  "total": float(total),
  # قيم Decimal للاستخدام الداخلي/الترحيل المحاسبي
  "\_subtotal": taxable\_base,
  "\_discount": discount,
  "\_tax": tax,
  "\_total": total,
  }
لماذا ينجح هذا مع الاختبار
الاختبار:
python
assert result\["total"] == sum(line\_total(l) for l in inv.lines) + result\["tax"]
في الكود الجديد:
result\["total"] = half\_up(subtotal - discount + tax)
sum(line\_total) + tax = subtotal + tax (بافتراض discount=0)
وبما أن subtotal وtax كلاهما مضاعفات للفلس (Decimal بـ 3 خانات)، فإن مجموعهما مضاعف للفلس أيضاً، وعملية quantize لا تغيّره. إذن الطرفان متساويان دائماً، وليس فقط لهذه الحالة.
نقاط مهمة في التصميم
Decimal بدل float: float لا يمثّل 2.885 أو 1.475 بدقة، وround في Python تستخدم banker's rounding لا half-up. Decimal + ROUND\_HALF\_UP يحلّ الأمرين.
تقريب واحد لكل سطر، وتقريب واحد للخصم، وتقريب واحد للضريبة — لا تقريب متسلسل للإجمالي من أرقام خام.
الإجمالي مشتق من المكوّنات المعروضة، فيستحيل أن يختلف عنها بفلس.
إرجاع float للعرض مع الاحتفاظ بـ Decimal في المفاتيح \_\* لأي ترحيل محاسبي لاحق.
حتمي بالكامل: لا اعتماد على ترتيب عمليات عائم، ولا على إعدادات محلية.
إذا كان برنامج المحاسبة يستقبل الإجمالي كـ float، فالحل أعلاه كافٍ. أما إذا كان يستقبل Decimal/نص، فاستخدم المفاتيح \_\* مباشرة ومرّرها كنص عبر str(value).
جGemini
سبب المشكلة الجذري يتلخص في نقطتين في الكود الحالي:التعامل مع الأعداد العشرية (float): دالة round() في بايثون تستخدم تقريب المصرفيين (Round to Even) وليس "النصف إلى الأعلى" (Half-Up)، كما أن حسابات float تُدخل أخطاء تمثيل ثنائي (Binary Floating-Point Inaccuracy) تجعل القيم مثل 8.655 تُخزن في الذاكرة كـ 8.654999999999999 فيتم تقريبها للأسفل بطريق الخطأ.تراكم تقريبات الأسطر مقابل المجموع: في اختبارك الحالي:السطر الأول: $3 \\times 2.885 = 8.655 \\xrightarrow{\\text{Half-Up}} 8.655$السطر الثاني: $2 \\times 1.475 = 2.950 \\xrightarrow{\\text{Half-Up}} 2.950$مجموع الأسطر = $11.605$ د.ك.الضريبة: $11.605 \\times 0.15 = 1.74075 \\xrightarrow{\\text{Half-Up}} 1.741$ د.ك.الإجمالي الصحيح رياضياً = $11.605 + 1.741 = 13.346$ د.ك.لكن دالة round() في بايثون مع float قرّبت $8.655$ إلى $8.654$ فظهر الناتج $11.771$ بدلاً من $11.772$ (حيث أُضيفت قيمة قديمة أو غير دقيقة).الحل النهائي (ملف invoicing.py معدل بالكامل)استخدام وحدة decimal من المكتبة القياسية لبايثون مع ضبط وضع التقريب على ROUND\_HALF\_UP يضمن الدقة المسبوقة بثلاث خانات عشرية مطابقة لمتطلبات المحاسبة الكويتية.Pythonfrom dataclasses import dataclass, field
from decimal import Decimal, ROUND\_HALF\_UP
\# معدل الضريبة كـ Decimal
TAX\_RATE = Decimal("0.15")
\# القيمة المرجعية للتقريب إلى 3 خانات عشرية (0.001)
KWD\_PRECISION = Decimal("0.001")
def round\_kwd(amount: Decimal) -> Decimal:
  """
  تقريب القيمة إلى أقرب فلس (3 خانات عشرية) باستخدام نظام Half-Up.
  """
  return amount.quantize(KWD\_PRECISION, rounding=ROUND\_HALF\_UP)
@dataclass
class Line:
  name: str
  qty: int
  unit\_price: Decimal
  def \_\_post\_init\_\_(self):
  # تحويل السعر تلقائياً إلى Decimal إذا أُمرِر كـ float أو int أو str
  if not isinstance(self.unit\_price, Decimal):
  self.unit\_price = Decimal(str(self.unit\_price))
@dataclass
class Invoice:
  lines: list\[Line] = field(default\_factory=list)
  discount: Decimal = Decimal("0.0") # إجمالي الخصم بالدينار الكويتي
  def \_\_post\_init\_\_(self):
  if not isinstance(self.discount, Decimal):
  self.discount = Decimal(str(self.discount))
def line\_total(line: Line) -> Decimal:
  """
  حساب إجمالي السطر مع تقريب كل سطر على حدة وفق سياسة العميل.
  """
  raw\_total = Decimal(line.qty) \* line.unit\_price
  return round\_kwd(raw\_total)
def compute\_invoice(inv: Invoice) -> dict\[str, Decimal]:
  """
  حساب إجمالي الفاتورة بحيث يكون الإجمالي دائماً مساوياً لمجموع الأسطر
  بعد خصم Discount مضافاً إليها الضريبة المحسوبة على ذلك الأساس.
  """
  # 1. مجموع الأسطر المقربة
  lines\_sum = sum((line\_total(l) for l in inv.lines), Decimal("0.000"))
  # 2. المجموع الفرعي بعد الخصم
  subtotal = round\_kwd(lines\_sum - inv.discount)
  # 3. حساب الضريبة على المجموع الفرعي الصافي وتقريبها لـ Half-Up
  tax = round\_kwd(subtotal \* TAX\_RATE)
  # 4. الإجمالي النهائي هو الجمع المباشر للمجموع الفرعي المقرب + الضريبة المقربة
  total = subtotal + tax
  return {
  "subtotal": subtotal,
  "tax": tax,
  "total": total,
  }
\# ----------------------------------------------------------------------
\# التحقق والاختبار التشغيلي
\# ----------------------------------------------------------------------
if \_\_name\_\_ == "\_\_main\_\_":
  inv = Invoice(
  lines=\[
  Line("برجر", 3, 2.885),
  Line("مشروب", 2, 1.475),
  ],
  discount=0.0,
  )
  result = compute\_invoice(inv)
  # طباعة التفاصيل
  print("المجموع الفرعي (Subtotal):", result\["subtotal"])
  print("الضريبة (Tax): ", result\["tax"])
  print("الإجمالي (Total): ", result\["total"])
  # التحقق المباشر المطلوبة في الـ CI
  expected\_total = sum(line\_total(l) for l in inv.lines) + result\["tax"]
  assert result\["total"] == expected\_total, f"Discrepancy: {result\['total']} != {expected\_total}"
  print("\\n✅ تم مجتاز اختبار المطابقة مع نظام ERP بنجاح!")
أبرز ما تم تعديله:استبدال float بـ Decimal: يضمن التخلص التام من أخطاء النقطة العائمة الثنائية.استخدام ROUND\_HALF\_UP: يُنفذ سياسة العميل بدقة (مثلاً $0.0005$ تُقرَّب إلى $0.001$).تطابق المعادلة مع الـ CI: تم ضمان شرط المطابقة حيث أصبح total = subtotal + tax كـ Decimal بدقة 100% دون خروج أي فلس زائد أو ناقص.