chellow 1757320031.0.0__py3-none-any.whl → 1759411815.0.0__py3-none-any.whl

chellow/e/bill_parsers/engie_edi.py

@@ -1,18 +1,15 @@
-from collections import defaultdict
 from decimal import Decimal
 
 
 from werkzeug.exceptions import BadRequest
 
 from chellow.edi_lib import (
-    ct_datetime,
     parse_edi,
     to_date,
     to_decimal,
     to_finish_date,
-    to_utc,
 )
-from chellow.utils import HH
+from chellow.utils import HH, parse_mpan_core
 
 
 read_type_map = {
@@ -30,86 +27,78 @@ read_type_map = {
 
 
 TCOD_MAP = {
-    "140114": ("reconciliation-gbp", None, None),
-    "255204": ("meter-rental-gbp", "meter-rental-rate", "meter-rental-days"),
-    "345065": ("op-weekend-gbp", "op-weekend-rate", "op-weekend-kwh"),
-    "350293": ("capacity-gbp", "capacity-rate", "capacity-kwh"),
-    "425779": ("ro-gbp", "ro-rate", "ro-kwh"),
-    "534342": ("reconciliation-gbp", None, None),
-    "583174": ("meter-rental-gbp", "meter-rental-rate", "meter-rental-days"),
-    "584867": ("aahedc-gbp", "aahedc-rate", "aahedc-kwh"),
-    "946827": ("meter-rental-gbp", "meter-rental-rate", "meter-rental-days"),
-    "989534": ("bsuos-gbp", "bsuos-rate", "bsuos-kwh"),
-    "117220": ("capacity-gbp", "capacity-rate", "capacity-kwh"),
-    "579387": ("capacity-gbp", "capacity-rate", "capacity-kwh"),
-    "558147": ("capacity-gbp", "capacity-rate", "capacity-kwh"),
-    "030025": ("ccl-gbp", "ccl-rate", "ccl-kwh"),
-    "066540": ("ccl-gbp", "ccl-rate", "ccl-kwh"),
-    "154164": ("cfd-fit-gbp", "cfd-fit-rate", "cfd-fit-kwh"),
-    "281170": ("cfd-fit-gbp", "cfd-fit-rate", "cfd-fit-kwh"),
-    "342094": ("cfd-fit-gbp", "cfd-fit-rate", "cfd-fit-kwh"),
-    "378809": ("cfd-fit-gbp", "cfd-fit-rate", "cfd-fit-kwh"),
-    "574015": ("cfd-fit-gbp", "cfd-fit-rate", "cfd-fit-kwh"),
-    "810016": ("cfd-fit-gbp", "cfd-fit-rate", "cfd-fit-kwh"),
-    "839829": ("cfd-fit-gbp", "cfd-fit-rate", "cfd-fit-kwh"),
-    "649282": ("cfd-fit-gbp", "cfd-fit-rate", "cfd-fit-kwh"),
-    "068476": ("day-gbp", "day-rate", "day-kwh"),
-    "133186": ("nrg-gbp", "nrg-rate", "nrg-kwh"),
-    "400434": ("day-gbp", "day-rate", "day-kwh"),
-    "219182": (
-        "duos-availability-gbp",
-        "duos-availability-rate",
-        "duos-availability-kva",
-    ),
-    "144424": (
-        "duos-excess-availability-gbp",
-        "duos-excess-availability-rate",
-        "duos-excess-availability-kva",
-    ),
-    "301541": ("duos-fixed-gbp", None, None),
-    "099335": ("duos-fixed-gbp", None, None),
-    "873562": ("duos-fixed-gbp", None, None),
-    "986159": ("duos-fixed-gbp", "duos-fixed-rate", "duos-fixed-days"),
-    "838286": ("duos-reactive-gbp", "duos-reactive-rate", "duos-reactive-kvarh"),
-    "242643": ("duos-fixed-gbp", "duos-fixed-rate", "duos-fixed-days"),
-    "257304": ("duos-amber-gbp", "duos-amber-rate", "duos-amber-kwh"),
-    "661440": ("duos-amber-gbp", "duos-amber-rate", "duos-amber-kwh"),
-    "257305": ("duos-green-gbp", "duos-green-rate", "duos-green-kwh"),
-    "661441": ("duos-green-gbp", "duos-green-rate", "duos-green-kwh"),
-    "257303": ("duos-red-gbp", "duos-red-rate", "duos-red-kwh"),
-    "661439": ("duos-red-gbp", "duos-red-rate", "duos-red-kwh"),
-    "504364": ("ebrs-gbp", None, "ebrs-kwh"),
-    "563023": ("ebrs-gbp", None, "ebrs-kwh"),
-    "823408": ("ebrs-gbp", None, "ebrs-kwh"),
-    "871593": ("ebrs-gbp", "ebrs-rate", "ebrs-kwh"),
-    "873894": ("ebrs-gbp", "ebrs-rate", "ebrs-kwh"),
-    "309707": ("fit-gbp", "fit-rate", "fit-kwh"),
-    "310129": ("meter-rental-gbp", None, None),
-    "452415": ("meter-rental-gbp", None, None),
-    "371265": ("meter-rental-gbp", None, None),
-    "544936": ("meter-rental-gbp", "meter-rental-rate", "meter-rental-days"),
-    "265091": ("night-gbp", "night-rate", "night-kwh"),
-    "483457": ("peak-gbp", "peak-rate", "peak-kwh"),
-    "975901": ("peak-shoulder-gbp", "peak-shoulder-rate", "peak-shoulder-kwh"),
-    "994483": ("reconciliation-gbp", None, None),
-    "637176": ("reconciliation-gbp", None, None),
-    "913821": ("reconciliation-gbp", None, None),
-    "307660": ("ro-gbp", "ro-rate", "ro-kwh"),
-    "364252": ("ro-gbp", "ro-rate", "ro-kwh"),
-    "378246": ("ro-gbp", "ro-rate", "ro-kwh"),
-    "708848": ("ro-gbp", None, None),
-    "632209": ("summer-night-gbp", "summer-night-rate", "summer-night-kwh"),
-    "663682": ("summer-weekday-gbp", "summer-weekday-rate", "summer-weekday-kwh"),
-    "299992": ("summer-weekend-gbp", "summer-weekend-rate", "summer-weekend-kwh"),
-    "211000": ("tnuos-gbp", "tnuos-rate", "tnuos-days"),
-    "790618": ("tnuos-gbp", None, None),
-    "447769": ("triad-gbp", "triad-rate", "triad-kw"),
-    "647721": ("triad-gbp", "triad-rate", "triad-kw"),
-    "276631": ("triad-gbp", "triad-rate", "triad-kw"),
-    "220894": ("winter-night-gbp", "winter-night-rate", "winter-night-kwh"),
-    "264929": ("winter-weekday-gbp", "winter-weekday-rate", "winter-weekday-kwh"),
-    "638187": ("winter-weekend-gbp", "winter-weekend-rate", "winter-weekend-kwh"),
-    "700285": ("standing-gbp", "standing-rate", "standing-days"),
+    "140114": ("reconciliation", None, None),
+    "255204": ("meter-rental", "rate", "days"),
+    "345065": ("op-weekend", "rate", "kwh"),
+    "350293": ("capacity", "rate", "kwh"),
+    "425779": ("ro", "rate", "kwh"),
+    "534342": ("reconciliation", None, None),
+    "583174": ("meter-rental", "rate", "days"),
+    "584867": ("aahedc", "rate", "kwh"),
+    "946827": ("meter-rental", "rate", "days"),
+    "989534": ("bsuos", "rate", "kwh"),
+    "117220": ("capacity", "rate", "kwh"),
+    "579387": ("capacity", "rate", "kwh"),
+    "558147": ("capacity", "rate", "kwh"),
+    "030025": ("ccl", "rate", "kwh"),
+    "066540": ("ccl", "rate", "kwh"),
+    "154164": ("cfd-fit", "rate", "kwh"),
+    "281170": ("cfd-fit", "rate", "fit-kwh"),
+    "342094": ("cfd-fit", "rate", "kwh"),
+    "378809": ("cfd-fit", "rate", "kwh"),
+    "574015": ("cfd-fit", "rate", "kwh"),
+    "810016": ("cfd-fit", "rate", "kwh"),
+    "839829": ("cfd-fit", "rate", "kwh"),
+    "649282": ("cfd-fit", "rate", "kwh"),
+    "068476": ("day", "rate", "kwh"),
+    "133186": ("nrg", "rate", "kwh"),
+    "400434": ("day", "rate", "kwh"),
+    "219182": ("duos-availability", "rate", "kva"),
+    "144424": ("duos-excess-availability", "rate", "kva"),
+    "301541": ("duos-fixed", None, None),
+    "099335": ("duos-fixed", None, None),
+    "873562": ("duos-fixed", None, None),
+    "986159": ("duos-fixed", "rate", "days"),
+    "838286": ("duos-reactive", "rate", "kvarh"),
+    "242643": ("duos-fixed", "rate", "days"),
+    "257304": ("duos-amber", "rate", "kwh"),
+    "661440": ("duos-amber", "rate", "kwh"),
+    "257305": ("duos-green", "rate", "kwh"),
+    "661441": ("duos-green", "rate", "kwh"),
+    "257303": ("duos-red", "rate", "kwh"),
+    "661439": ("duos-red", "rate", "kwh"),
+    "504364": ("ebrs", None, "kwh"),
+    "563023": ("ebrs", None, "kwh"),
+    "823408": ("ebrs", None, "kwh"),
+    "871593": ("ebrs", "rate", "kwh"),
+    "873894": ("ebrs", "rate", "kwh"),
+    "309707": ("fit", "rate", "kwh"),
+    "310129": ("meter-rental", None, None),
+    "452415": ("meter-rental", None, None),
+    "371265": ("meter-rental", None, None),
+    "544936": ("meter-rental", "rate", "days"),
+    "265091": ("night", "rate", "kwh"),
+    "483457": ("peak", "rate", "kwh"),
+    "975901": ("peak-shoulder", "rate", "kwh"),
+    "994483": ("reconciliation", None, None),
+    "637176": ("reconciliation", None, None),
+    "913821": ("reconciliation", None, None),
+    "307660": ("ro", "rate", "kwh"),
+    "364252": ("ro", "rate", "kwh"),
+    "378246": ("ro", "rate", "kwh"),
+    "708848": ("ro", None, None),
+    "632209": ("summer-night", "rate", "kwh"),
+    "663682": ("summer-weekday", "rate", "kwh"),
+    "299992": ("summer-weekend", "rate", "kwh"),
+    "211000": ("tnuos", "rate", "days"),
+    "790618": ("tnuos", None, None),
+    "447769": ("triad", "rate", "kw"),
+    "647721": ("triad", "rate", "kw"),
+    "276631": ("triad", "rate", "kw"),
+    "220894": ("winter-night", "rate", "kwh"),
+    "264929": ("winter-weekday", "rate", "kwh"),
+    "638187": ("winter-weekend", "rate", "kwh"),
+    "700285": ("standing", "rate", "days"),
 }
 
 TPR_LOOKUP = {
@@ -125,10 +114,40 @@ def _process_BCD(elements, headers):
     issue_date = to_date(elements["IVDT"][0])
     reference = elements["INVN"][0]
     bill_type_code = elements["BTCD"][0]
+    sumo = elements["SUMO"]
 
     headers["issue_date"] = issue_date
+    headers["start_date"] = to_date(sumo[0])
+    headers["finish_date"] = to_date(sumo[1]) - HH
     headers["bill_type_code"] = bill_type_code
     headers["reference"] = reference
+    headers["elements"] = []
+    headers["reads"] = []
+    headers["breakdown"] = {}
+    headers["kwh"] = Decimal("0")
+
+
+def _process_BTL(elements, headers):
+    uvlt = elements["UVLT"]
+    utva = elements["UTVA"]
+    tbtl = elements["TBTL"]
+
+    return {
+        "bill_type_code": headers["bill_type_code"],
+        "reference": headers["reference"],
+        "issue_date": headers["issue_date"],
+        "mpan_core": headers["mpan_core"],
+        "account": headers["account"],
+        "start_date": headers["start_date"],
+        "finish_date": headers["finish_date"],
+        "kwh": headers["kwh"],
+        "net": Decimal("0.00") + to_decimal(uvlt) / Decimal("100"),
+        "vat": Decimal("0.00") + to_decimal(utva) / Decimal("100"),
+        "gross": Decimal("0.00") + to_decimal(tbtl) / Decimal("100"),
+        "breakdown": headers["breakdown"],
+        "reads": headers["reads"],
+        "elements": headers["elements"],
+    }
 
 
 def _process_CCD1(elements, headers):
@@ -161,12 +180,7 @@ def _process_CCD1(elements, headers):
         units = "kWh"
         tpr_code = TPR_LOOKUP[tcod[1]]
 
-    try:
-        reads = headers["reads"]
-    except KeyError:
-        reads = headers["reads"] = []
-
-    reads.append(
+    headers["reads"].append(
         {
             "msn": msn,
             "mpan": mpan,
@@ -184,189 +198,112 @@ def _process_CCD1(elements, headers):
 
 
 def _process_CCD2(elements, headers):
-    breakdown = defaultdict(int)
+    breakdown = {}
 
     element_code = elements["TCOD"][0]
-    headers["element_code"] = element_code
     try:
-        eln_gbp, eln_rate, eln_cons = TCOD_MAP[element_code]
+        eln_name, eln_rate, eln_cons = TCOD_MAP[element_code]
     except KeyError:
         raise BadRequest(f"Can't find the element code {element_code} in the TCOD_MAP.")
 
-    m = elements["MLOC"][0]
-    mpan_core = " ".join((m[:2], m[2:6], m[6:10], m[10:]))
-
     cons = elements["CONS"]
-    kwh = Decimal("0")
     if eln_cons is not None and len(cons[0]) > 0:
         el_cons = to_decimal(cons) / Decimal("1000")
-        if eln_gbp == "duos-availability-gbp":
-            breakdown[eln_cons] = [el_cons]
+        if eln_name == "duos-availability":
+            breakdown[eln_cons] = {el_cons}
         else:
-            breakdown[eln_cons] = kwh = el_cons
+            breakdown[eln_cons] = el_cons
+            if eln_name == "ro":
+                headers["kwh"] += el_cons
 
     if eln_rate is not None:
         rate = to_decimal(elements["BPRI"]) / Decimal("100000")
-        breakdown[eln_rate] = [rate]
-
-    start_date = to_date(elements["CSDT"][0])
-    headers["bill_start_date"] = start_date
-
-    finish_date = to_date(elements["CEDT"][0]) - HH
-    headers["bill_finish_date"] = finish_date
+        breakdown[eln_rate] = {rate}
 
+    net = Decimal("0.00")
     if "CTOT" in elements:
-        net = Decimal("0.00") + to_decimal(elements["CTOT"]) / Decimal("100")
-    else:
-        net = Decimal("0.00")
-
-    breakdown[eln_gbp] = net
-
-    headers["mpan_core"] = mpan_core
-
-    try:
-        reads = headers["reads"]
-        headers["reads"] = []
-    except KeyError:
-        reads = []
+        net += to_decimal(elements["CTOT"]) / Decimal("100")
 
-    return {
-        "bill_type_code": headers["bill_type_code"],
-        "reference": headers["reference"] + "_" + eln_gbp[:-4],
-        "issue_date": headers["issue_date"],
-        "mpan_core": mpan_core,
-        "account": mpan_core,
-        "start_date": start_date,
-        "finish_date": finish_date,
-        "kwh": kwh if eln_gbp == "ro-gbp" else Decimal("0"),
-        "net": net,
-        "vat": Decimal("0.00"),
-        "gross": net,
-        "breakdown": breakdown,
-        "reads": reads,
-    }
+    headers["elements"].append(
+        {
+            "name": eln_name,
+            "start_date": to_date(elements["CSDT"][0]),
+            "finish_date": to_date(elements["CEDT"][0]) - HH,
+            "net": net,
+            "breakdown": breakdown,
+        }
+    )
 
 
 def _process_CCD3(elements, headers):
-    breakdown = defaultdict(int)
+    breakdown = {}
 
     element_code = elements["TCOD"][0]
-    headers["element_code"] = element_code
     try:
-        eln_gbp, eln_rate, eln_cons = TCOD_MAP[element_code]
+        eln_name, eln_rate, eln_cons = TCOD_MAP[element_code]
     except KeyError:
         raise BadRequest(f"Can't find the element code {element_code} in the TCOD_MAP.")
 
-    m = elements["MLOC"][0]
-    mpan_core = " ".join((m[:2], m[2:6], m[6:10], m[10:]))
-
     cons = elements["CONS"]
     if eln_cons is not None and len(cons[0]) > 0:
         el_cons = to_decimal(cons) / Decimal("1000")
-        breakdown[eln_cons] = kwh = el_cons
-    else:
-        kwh = Decimal("0")
+        breakdown[eln_cons] = el_cons
+        if eln_name == "ro":
+            headers["kwh"] += el_cons
 
     if eln_rate is not None:
         rate = to_decimal(elements["BPRI"]) / Decimal("100000")
-        breakdown[eln_rate] = [rate]
-
-    start_date = to_date(elements["CSDT"][0])
-    headers["bill_start_date"] = start_date
-
-    finish_date = to_date(elements["CEDT"][0]) - HH
-    headers["bill_finish_date"] = finish_date
+        breakdown[eln_rate] = {rate}
 
+    net = Decimal("0.00")
     if "CTOT" in elements:
-        net = Decimal("0.00") + to_decimal(elements["CTOT"]) / Decimal("100")
-    else:
-        net = Decimal("0.00")
-
-    breakdown[eln_gbp] = net
+        net += to_decimal(elements["CTOT"]) / Decimal("100")
 
-    headers["mpan_core"] = mpan_core
-
-    try:
-        reads = headers["reads"]
-        headers["reads"] = []
-    except KeyError:
-        reads = []
-
-    return {
-        "bill_type_code": headers["bill_type_code"],
-        "issue_date": headers["issue_date"],
-        "reference": headers["reference"] + "_" + eln_gbp[:-4],
-        "mpan_core": mpan_core,
-        "account": mpan_core,
-        "start_date": start_date,
-        "finish_date": finish_date,
-        "net": net,
-        "kwh": kwh if eln_gbp == "ro-gbp" else Decimal("0"),
-        "vat": Decimal("0.00"),
-        "gross": net,
-        "breakdown": breakdown,
-        "reads": reads,
-    }
+    headers["elements"].append(
+        {
+            "name": eln_name,
+            "start_date": to_date(elements["CSDT"][0]),
+            "finish_date": to_date(elements["CEDT"][0]) - HH,
+            "net": net,
+            "breakdown": breakdown,
+        }
+    )
 
 
 def _process_CCD4(elements, headers):
-    breakdown = defaultdict(int)
+    breakdown = {}
 
     element_code = elements["TCOD"][0]
-    headers["element_code"] = element_code
+
     try:
-        eln_gbp, eln_rate, eln_cons = TCOD_MAP[element_code]
+        eln_name, eln_rate, eln_cons = TCOD_MAP[element_code]
     except KeyError:
         raise BadRequest(f"Can't find the element code {element_code} in the TCOD_MAP.")
 
-    m = elements["MLOC"][0]
-    mpan_core = " ".join((m[:2], m[2:6], m[6:10], m[10:]))
-
     cons = elements["CONS"]
     if eln_cons is not None and len(cons[0]) > 0:
         el_cons = to_decimal(cons, "1000")
-        breakdown[eln_cons] = kwh = el_cons
+        breakdown[eln_cons] = el_cons
+        if eln_name == "ro":
+            headers["kwh"] += el_cons
 
     if eln_rate is not None:
         rate = to_decimal(elements["BPRI"], "100000")
         breakdown[eln_rate] = [rate]
 
-    start_date = to_date(elements["CSDT"][0])
-    headers["bill_start_date"] = start_date
-
-    finish_date = to_date(elements["CEDT"][0]) - HH
-    headers["bill_finish_date"] = finish_date
-
+    net = Decimal("0.00")
     if "CTOT" in elements:
-        net = Decimal("0.00") + to_decimal(elements["CTOT"], "100")
-    else:
-        net = Decimal("0.00")
-
-    breakdown[eln_gbp] = net
-
-    headers["mpan_core"] = mpan_core
-
-    try:
-        reads = headers["reads"]
-        del headers["reads"][:]
-    except KeyError:
-        reads = []
+        net += to_decimal(elements["CTOT"], "100")
 
-    return {
-        "kwh": kwh if eln_gbp == "ro-gbp" else Decimal("0.00"),
-        "reference": headers["reference"] + "_" + eln_gbp[:-4],
-        "issue_date": headers["issue_date"],
-        "mpan_core": mpan_core,
-        "account": mpan_core,
-        "start_date": start_date,
-        "finish_date": finish_date,
-        "net": net,
-        "vat": Decimal("0.00"),
-        "gross": net,
-        "breakdown": breakdown,
-        "reads": reads,
-        "bill_type_code": headers["bill_type_code"],
-    }
+    headers["elements"].append(
+        {
+            "name": eln_name,
+            "start_date": to_date(elements["CSDT"][0]),
+            "finish_date": to_date(elements["CEDT"][0]) - HH,
+            "net": net,
+            "breakdown": breakdown,
+        }
+    )
 
 
 def _process_CDT(elements, headers):
@@ -374,10 +311,20 @@ def _process_CDT(elements, headers):
     headers["customer_number"] = customer_id
 
 
+def _process_CLO(elements, headers):
+    cloc = elements["CLOC"]
+    headers["account"] = cloc[2]
+
+
 def _process_END(elements, headers):
     pass
 
 
+def _process_MAN(elements, headers):
+    madn = elements["MADN"]
+    headers["mpan_core"] = parse_mpan_core("".join(madn[:3]))
+
+
 def _process_MHD(elements, headers):
     message_type = elements["TYPE"][0]
     if message_type == "UTLBIL":
@@ -396,21 +343,14 @@ def _process_VAT(elements, headers):
     vat_percentage = to_decimal(elements["VATP"]) / Decimal("1000")
     vat_net = Decimal("0.00") + to_decimal(elements["UVLA"]) / Decimal("100")
 
-    return {
-        "bill_type_code": headers["bill_type_code"],
-        "account": headers["mpan_core"],
-        "mpan_core": headers["mpan_core"],
-        "reference": headers["reference"] + "_vat",
-        "issue_date": headers["issue_date"],
-        "start_date": headers["bill_start_date"],
-        "finish_date": headers["bill_finish_date"],
-        "kwh": Decimal("0.00"),
-        "net": Decimal("0.00"),
-        "vat": vat,
-        "gross": vat,
-        "breakdown": {"vat": {vat_percentage: {"vat": vat, "net": vat_net}}},
-        "reads": [],
-    }
+    breakdown = headers["breakdown"]
+
+    try:
+        vat_bd = breakdown["vat"]
+    except KeyError:
+        vat_bd = breakdown["vat"] = {}
+
+    vat_bd[vat_percentage] = {"vat": vat, "net": vat_net}
 
 
 def _process_NOOP(elements, headers):
@@ -419,17 +359,17 @@ def _process_NOOP(elements, headers):
 
 CODE_FUNCS = {
     "BCD": _process_BCD,
-    "BTL": _process_NOOP,
+    "BTL": _process_BTL,
     "CCD1": _process_CCD1,
     "CCD2": _process_CCD2,
     "CCD3": _process_CCD3,
     "CCD4": _process_CCD4,
     "CDT": _process_CDT,
-    "CLO": _process_NOOP,
+    "CLO": _process_CLO,
     "DNA": _process_NOOP,
     "END": _process_END,
     "FIL": _process_NOOP,
-    "MAN": _process_NOOP,
+    "MAN": _process_MAN,
     "MHD": _process_MHD,
     "MTR": _process_MTR,
     "SDT": _process_NOOP,
@@ -441,21 +381,6 @@ CODE_FUNCS = {
 }
 
 
-def _customer_mods(headers, bill):
-    if headers["customer_number"] == "WESSEXWAT":
-        if (
-            headers["element_code"] == "307660"
-            and "ro-gbp" in bill["breakdown"]
-            and bill["issue_date"] == to_utc(ct_datetime(2023, 4, 14))
-            and bill["start_date"] == to_utc(ct_datetime(2023, 3, 1))
-            and bill["finish_date"] == to_utc(ct_datetime(2023, 3, 31, 23, 30))
-        ):
-            bill["start_date"] = to_utc(ct_datetime(2021, 4, 1))
-            bill["finish_date"] = to_utc(ct_datetime(2022, 3, 31, 23, 30))
-
-    return bill
-
-
 class Parser:
     def __init__(self, f):
         self.edi_str = str(f.read(), "utf-8", errors="ignore")
@@ -465,7 +390,12 @@ class Parser:
         bills = []
         headers = {}
         bill = None
+        lines = []
         for self.line_number, line, seg_name, elements in parse_edi(self.edi_str):
+            if seg_name == "MHD":
+                lines = []
+            lines.append(line)
+
             try:
                 func = CODE_FUNCS[seg_name]
             except KeyError:
@@ -485,7 +415,9 @@ class Parser:
                 ) from e
 
             if bill is not None:
-                bill["breakdown"]["raw-lines"] = [line]
-                bills.append(_customer_mods(headers, bill))
+                bill["breakdown"]["raw-lines"] = lines
+                bills.append(bill)
+            if seg_name == "MTR":
+                lines = []
 
         return bills