chellow 1744710468.0.0__tar.gz → 1745313690.0.0__tar.gz

{chellow-1744710468.0.0 → chellow-1745313690.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chellow
-Version: 1744710468.0.0
+Version: 1745313690.0.0
 Summary: Web Application for checking UK energy bills.
 Project-URL: Homepage, https://github.com/WessexWater/chellow
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)

chellow-1745313690.0.0/VERSION

@@ -0,0 +1 @@
+__version__ = "1745313690.0.0"

{chellow-1744710468.0.0 → chellow-1745313690.0.0}/chellow/__init__.py

@@ -22,6 +22,7 @@ import chellow.e.hh_importer
 import chellow.e.rcrc
 import chellow.e.system_price
 import chellow.e.views
+import chellow.fake_batch_updater
 import chellow.gas.cv
 import chellow.gas.views
 import chellow.national_grid
@@ -62,6 +63,7 @@ def get_importer_modules():
         chellow.national_grid,
         chellow.rate_server,
         chellow.rrun,
+        chellow.fake_batch_updater,
     )
 
 

{chellow-1744710468.0.0 → chellow-1745313690.0.0}/chellow/e/bill_parsers/mm.py

@@ -59,7 +59,7 @@ def _handle_0100(headers, pre_record, record):
     headers["issue_date"] = issue_date
     if late_payment is not None:
         headers["late_payment"] = late_payment
-    headers["account"] = pre_record[33:41]
+    headers["account"] = pre_record[43:52]
     headers["reference"] = pre_record[41:46]
     headers["kwh"] = Decimal("0")
     headers["breakdown"] = defaultdict(int, {"vat": {}})

{chellow-1744710468.0.0 → chellow-1745313690.0.0}/chellow/e/bill_parsers/nonsettlement_dc_stark_xlsx.py

@@ -4,6 +4,7 @@ from openpyxl import load_workbook
 
 from werkzeug.exceptions import BadRequest
 
+from chellow.e.computer import hh_rate
 from chellow.models import Session
 from chellow.utils import ct_datetime, parse_mpan_core, to_utc
 
@@ -16,12 +17,6 @@ def get_start_date(title_row, row, name):
     return to_utc(get_ct_date(title_row, row, name))
 
 
-def get_finish_date(title_row, row, name):
-    d = get_ct_date(title_row, row, name)
-
-    return to_utc(ct_datetime(d.year, d.month, d.day, 23, 30))
-
-
 def get_value(title_row, row, name):
     idx = None
     name = name.strip().lower()
@@ -61,9 +56,6 @@ def get_int(title_row, row, name):
     return int(get_value(title_row, row, name))
 
 
-METER_RATE = Decimal("60.00")
-
-
 class Parser:
     def __init__(self, f):
         self.book = load_workbook(f)
@@ -86,6 +78,7 @@ class Parser:
 
     def make_raw_bills(self):
         row_index = None
+        caches = {}
         try:
             with Session() as sess:
                 bills = []
@@ -101,14 +94,30 @@ class Parser:
                     mpan_core = parse_mpan_core(
                         str(get_int(title_row, row, "mpan ref"))
                     )
-                    start_date = get_start_date(title_row, row, "start")
+                    start_date_ct = get_ct_date(title_row, row, "start")
+                    start_date = to_utc(start_date_ct)
                     issue_date = start_date
-                    finish_date = get_finish_date(title_row, row, "end")
+                    finish_date_ct = get_ct_date(title_row, row, "end")
+                    finish_date = to_utc(
+                        ct_datetime(
+                            finish_date_ct.year,
+                            finish_date_ct.month,
+                            finish_date_ct.day,
+                            23,
+                            30,
+                        )
+                    )
                     check = get_str(title_row, row, "check")
                     if check != "Billed":
                         continue
-
-                    net = METER_RATE / 12
+                    rates = hh_rate(sess, caches, 0, start_date)
+                    meter_rate = rates["annual_rates"]["non_settlement"]["*"]["IP"][
+                        "*"
+                    ]["gbp_per_meter"]
+                    months = (finish_date_ct.year - start_date_ct.year) * 12 + (
+                        finish_date_ct.month - start_date_ct.month + 1
+                    )
+                    net = round(Decimal(float(meter_rate) / 12 * months), 2)
                     vat = round(net * Decimal("0.2"), 2)
 
                     breakdown = {
@@ -116,7 +125,8 @@ class Parser:
                         "cop": ["5"],
                         "settlement-status": ["non_settlement"],
                         "msn": [msn],
-                        "meter-rate": [METER_RATE],
+                        "meter-rate": [meter_rate],
+                        "months": months,
                         "meter-gbp": net,
                     }
 

{chellow-1744710468.0.0 → chellow-1745313690.0.0}/chellow/e/dno_rate_parser.py

@@ -650,15 +650,15 @@ def update_vls(sess, logger, vls, dno_code, fy_start, rs_finish):
         llfc = sess.execute(q).scalar_one_or_none()
 
         if llfc is None:
-            raise BadRequest(
+            logger(
                 f"There is no LLFC with the code '{vl_code}' associated with the DNO "
-                f"{dno.code} from {hh_format(fy_start)} to {hh_format(rs_finish)}."
+                f"{dno.dno_code} from {hh_format(fy_start)} to {hh_format(rs_finish)}."
             )
-
-        vl_voltage_level = VoltageLevel.get_by_code(sess, vl["voltage_level"])
-        llfc.voltage_level = vl_voltage_level
-
-        llfc.is_substation = vl["is_substation"]
-        if sess.is_modified(llfc):
-            logger(f"Updated LLFC {llfc.code} of DNO {dno_code}")
-            sess.flush()
+        else:
+            vl_voltage_level = VoltageLevel.get_by_code(sess, vl["voltage_level"])
+            llfc.voltage_level = vl_voltage_level
+
+            llfc.is_substation = vl["is_substation"]
+            if sess.is_modified(llfc):
+                logger(f"Updated LLFC {llfc.code} of DNO {dno_code}")
+                sess.flush()

chellow-1745313690.0.0/chellow/fake_batch_updater.py

@@ -0,0 +1,305 @@
+import atexit
+import collections
+import threading
+import traceback
+from datetime import timedelta
+
+from sqlalchemy import false, null, select
+
+from werkzeug.exceptions import BadRequest
+
+from chellow.e.computer import contract_func
+from chellow.gas.engine import g_contract_func
+from chellow.models import (
+    Batch,
+    BillType,
+    Contract,
+    GBatch,
+    GBill,
+    GContract,
+    GRateScript,
+    GReadType,
+    GSupply,
+    GUnit,
+    RateScript,
+    ReadType,
+    Session,
+    Supply,
+    Tpr,
+)
+from chellow.utils import (
+    c_months_u,
+    ct_datetime_now,
+    hh_format,
+    keydefaultdict,
+    utc_datetime_now,
+)
+
+
+importer = None
+
+
+def run_import(sess, log, set_progress):
+    log("Starting to update the fake batches")
+    caches = {}
+
+    now_ct = ct_datetime_now()
+    (last_month_start, last_month_finish), (
+        current_month_start,
+        current_month_finish,
+    ) = list(c_months_u(finish_year=now_ct.year, finish_month=now_ct.month, months=2))
+
+    for last_rate_script in sess.scalars(
+        select(RateScript)
+        .join(Contract, RateScript.contract_id == Contract.id)
+        .where(RateScript.finish_date == null())
+    ):
+        contract = last_rate_script.contract
+        fb_func = contract_func(caches, contract, "make_fake_bills")
+        if fb_func is None:
+            continue
+
+        fake_batch_name = f"fake_e_batch_{contract.id}"
+
+        fake_batch = sess.scalar_one_or_none(
+            select(Batch).where(
+                Batch.contract == contract,
+                Batch.reference == fake_batch_name,
+            )
+        )
+
+        if fake_batch is not None and fake_batch.start_date < current_month_start:
+            fake_batch.delete(sess)
+            sess.flush()
+            fake_batch = None
+
+        if fake_batch is None:
+            fake_batch = contract.insert_batch(sess, fake_batch_name, "Fake Batch")
+            bill_types = keydefaultdict(lambda k: BillType.get_by_code(sess, k))
+
+            tprs = keydefaultdict(
+                lambda k: None if k is None else Tpr.get_by_code(sess, k)
+            )
+
+            read_types = keydefaultdict(lambda k: ReadType.get_by_code(sess, k))
+            for raw_bill in fb_func(
+                sess,
+                log,
+                last_month_start,
+                last_month_finish,
+                current_month_start,
+                current_month_finish,
+            ):
+                mpan_core = raw_bill["mpan_core"]
+                supply = Supply.get_by_mpan_core(sess, mpan_core)
+                bill = fake_batch.insert_bill(
+                    sess,
+                    raw_bill["account"],
+                    raw_bill["reference"],
+                    raw_bill["issue_date"],
+                    raw_bill["start_date"],
+                    raw_bill["finish_date"],
+                    raw_bill["kwh"],
+                    raw_bill["net"],
+                    raw_bill["vat"],
+                    raw_bill["gross"],
+                    bill_types[raw_bill["bill_type_code"]],
+                    raw_bill["breakdown"],
+                    supply,
+                )
+                for raw_read in raw_bill["reads"]:
+                    bill.insert_read(
+                        sess,
+                        tprs[raw_read["tpr_code"]],
+                        raw_read["coefficient"],
+                        raw_read["units"],
+                        raw_read["msn"],
+                        raw_read["mpan"],
+                        raw_read["prev_date"],
+                        raw_read["prev_value"],
+                        read_types[raw_read["prev_type_code"]],
+                        raw_read["pres_date"],
+                        raw_read["pres_value"],
+                        read_types[raw_read["pres_type_code"]],
+                    )
+    for last_rate_script in sess.scalars(
+        select(GRateScript)
+        .join(GContract, GRateScript.g_contract_id == GContract.id)
+        .where(GContract.is_industry == false(), GRateScript.finish_date == null())
+    ):
+        g_contract = last_rate_script.g_contract
+        log(f"Looking at gas contract {g_contract.name}")
+        fb_func = g_contract_func(caches, g_contract, "make_fake_bills")
+        if fb_func is None:
+            log("Doesn't have a make_fake_bills function so skipping")
+            continue
+
+        fake_batch_name = f"fake_g_batch_{g_contract.id}"
+
+        fake_batch = sess.scalars(
+            select(GBatch).where(
+                GBatch.g_contract == g_contract,
+                GBatch.reference == fake_batch_name,
+            )
+        ).one_or_none()
+
+        if fake_batch is not None:
+            first_fake_bill = sess.scalars(
+                select(GBill)
+                .where(GBill.g_batch == fake_batch)
+                .order_by(GBill.start_date)
+            ).first()
+            if (
+                first_fake_bill is None
+                or first_fake_bill.start_date < current_month_start
+            ):
+                fake_batch.delete(sess)
+                sess.flush()
+                fake_batch = None
+
+        if fake_batch is None:
+            fake_batch = g_contract.insert_g_batch(sess, fake_batch_name, "Fake Batch")
+            raw_bills = fb_func(
+                sess,
+                log,
+                last_month_start,
+                last_month_finish,
+                current_month_start,
+                current_month_finish,
+            )
+            if raw_bills is not None and len(raw_bills) > 0:
+                for raw_bill in raw_bills:
+                    bill_type = BillType.get_by_code(sess, raw_bill["bill_type_code"])
+                    g_supply = GSupply.get_by_mprn(sess, raw_bill["mprn"])
+                    g_bill = fake_batch.insert_g_bill(
+                        sess,
+                        g_supply,
+                        bill_type,
+                        raw_bill["reference"],
+                        raw_bill["account"],
+                        raw_bill["issue_date"],
+                        raw_bill["start_date"],
+                        raw_bill["finish_date"],
+                        raw_bill["kwh"],
+                        raw_bill["net_gbp"],
+                        raw_bill["vat_gbp"],
+                        raw_bill["gross_gbp"],
+                        raw_bill["raw_lines"],
+                        raw_bill["breakdown"],
+                    )
+                    sess.flush()
+                    for raw_read in raw_bill["reads"]:
+                        prev_type = GReadType.get_by_code(
+                            sess, raw_read["prev_type_code"]
+                        )
+                        pres_type = GReadType.get_by_code(
+                            sess, raw_read["pres_type_code"]
+                        )
+                        g_unit = GUnit.get_by_code(sess, raw_read["unit"])
+                        g_bill.insert_g_read(
+                            sess,
+                            raw_read["msn"],
+                            g_unit,
+                            raw_read["correction_factor"],
+                            raw_read["calorific_value"],
+                            raw_read["prev_value"],
+                            raw_read["prev_date"],
+                            prev_type,
+                            raw_read["pres_value"],
+                            raw_read["pres_date"],
+                            pres_type,
+                        )
+                    sess.commit()
+
+
+LAST_RUN_KEY = "fake_batch_updater_last_run"
+
+
+class FakeBatchUpdater(threading.Thread):
+    def __init__(self):
+        super().__init__(name="Fake Batch Updater")
+        self.messages = collections.deque(maxlen=500)
+        self.progress = ""
+        self.stopped = threading.Event()
+        self.going = threading.Event()
+        self.global_alert = None
+
+    def stop(self):
+        self.stopped.set()
+        self.going.set()
+        self.join()
+
+    def go(self):
+        self.going.set()
+
+    def log(self, message):
+        self.messages.appendleft(
+            f"{ct_datetime_now().strftime('%Y-%m-%d %H:%M:%S')} - {message}"
+        )
+
+    def set_progress(self, progress):
+        self.progress = progress
+
+    def run(self):
+        while not self.stopped.is_set():
+            with Session() as sess:
+                try:
+                    config = Contract.get_non_core_by_name(sess, "configuration")
+                    state = config.make_state()
+                except BaseException as e:
+                    msg = f"{e.description} " if isinstance(e, BadRequest) else ""
+                    self.log(f"{msg}{traceback.format_exc()}")
+                    self.global_alert = (
+                        "There's a problem with a <a href='/fake_batch_updater'>"
+                        "Fake Batch Updater</a>."
+                    )
+                    sess.rollback()
+
+            last_run = state.get(LAST_RUN_KEY)
+            if last_run is None or utc_datetime_now() - last_run > timedelta(days=1):
+                self.going.set()
+
+            if self.going.is_set():
+                self.global_alert = None
+                with Session() as sess:
+                    try:
+                        config = Contract.get_non_core_by_name(sess, "configuration")
+                        state = config.make_state()
+                        state[LAST_RUN_KEY] = utc_datetime_now()
+                        config.update_state(state)
+                        sess.commit()
+                        run_import(sess, self.log, self.set_progress)
+                    except BaseException as e:
+                        msg = f"{e.description} " if isinstance(e, BadRequest) else ""
+                        self.log(f"{msg}{traceback.format_exc()}")
+                        self.global_alert = (
+                            "There's a problem with a "
+                            "<a href='/fake_batch_updater'>Fake Batch Updater</a>."
+                        )
+                        sess.rollback()
+                    finally:
+                        self.going.clear()
+                        self.log("Finished updating fake batches.")
+
+            else:
+                self.log(
+                    f"The updater was last run at {hh_format(last_run)}. There will "
+                    f"be another update when a hour has elapsed since the last run."
+                )
+                self.going.wait(60 * 60)
+
+
+def get_importer():
+    return importer
+
+
+def startup():
+    global importer
+    importer = FakeBatchUpdater()
+    importer.start()
+
+
+@atexit.register
+def shutdown():
+    if importer is not None:
+        importer.stop()

chellow-1745313690.0.0/chellow/reports/report_missing_bills.py

@@ -0,0 +1,158 @@
+import csv
+import threading
+import traceback
+
+from flask import g, redirect
+
+
+from sqlalchemy import null, or_, select
+from sqlalchemy.orm import joinedload
+
+from chellow.dloads import open_file
+from chellow.models import Batch, Bill, Contract, Era, RSession, ReportRun, User
+from chellow.utils import (
+    c_months_u,
+    csv_make_val,
+    hh_max,
+    hh_min,
+    hh_range,
+    req_date,
+    req_int,
+)
+
+
+def content(user_id, report_run_id, contract_id, months_length, finish_date):
+    f = writer = None
+    try:
+        with RSession() as sess:
+            caches = {}
+            contract = Contract.get_by_id(sess, contract_id)
+            user = User.get_by_id(sess, user_id)
+            f = open_file(
+                f"missing_bills_{contract.id}.csv", user, mode="w", newline=""
+            )
+            writer = csv.writer(f, lineterminator="\n")
+            titles = (
+                "contract_name",
+                "month_start",
+                "month_finish",
+                "site_code",
+                "site_name",
+                "imp_mpan_core",
+                "exp_mpan_core",
+                "account",
+            )
+            writer.writerow(titles)
+
+            months = list(
+                c_months_u(
+                    finish_year=finish_date.year,
+                    finish_month=finish_date.month,
+                    months=months_length,
+                )
+            )
+
+            for month_start, month_finish in months:
+                missing_bills = {}
+                missing_account = {}
+                account_missing_tuple = hh_range(caches, month_start, month_finish)
+                for era in sess.scalars(
+                    select(Era)
+                    .where(
+                        Era.start_date <= month_finish,
+                        or_(Era.finish_date == null(), Era.finish_date >= month_start),
+                        or_(
+                            Era.mop_contract == contract,
+                            Era.dc_contract == contract,
+                            Era.imp_supplier_contract == contract,
+                            Era.exp_supplier_contract == contract,
+                        ),
+                    )
+                    .options(joinedload(Era.supply))
+                ):
+                    chunk_start = hh_max(era.start_date, month_start)
+                    chunk_finish = hh_min(era.finish_date, month_finish)
+                    missing_set = set(hh_range(caches, chunk_start, chunk_finish))
+                    if era.mop_contract == contract:
+                        account = era.mop_account
+                    elif era.dc_contract == contract:
+                        account = era.dc_account
+                    elif era.imp_supplier_contract == contract:
+                        account = era.imp_supplier_account
+                    elif era.imp_supplier_contract == contract:
+                        account = era.exp_supplier_account
+
+                    try:
+                        account_missing_set = missing_account[account]
+                    except KeyError:
+                        account_missing_set = missing_account[account] = set(
+                            account_missing_tuple
+                        )
+                    supply = era.supply
+
+                    for bill in sess.scalars(
+                        select(Bill)
+                        .join(Batch)
+                        .where(
+                            Batch.contract == contract,
+                            Bill.supply == supply,
+                            Bill.start_date <= chunk_finish,
+                            Bill.finish_date >= chunk_start,
+                        )
+                    ):
+                        found_set = set(
+                            hh_range(caches, bill.start_date, bill.finish_date)
+                        )
+                        missing_set.difference_update(found_set)
+                        account_missing_set.difference_update(found_set)
+
+                    if len(missing_set) > 0:
+                        site = era.get_physical_site(sess)
+
+                        values = {
+                            "contract_id": contract.id,
+                            "contract_name": contract.name,
+                            "month_start": month_start,
+                            "month_finish": month_finish,
+                            "era_id": era.id,
+                            "supply_id": supply.id,
+                            "imp_mpan_core": era.imp_mpan_core,
+                            "exp_mpan_core": era.exp_mpan_core,
+                            "site_id": site.id,
+                            "site_code": site.code,
+                            "site_name": site.name,
+                            "account": account,
+                            "market_role_code": contract.market_role.code,
+                        }
+                        missing_bills[era.id] = values
+        for era_id, values in missing_bills.items():
+            if len(missing_account[values["account"]]) > 0:
+                writer.writerow(csv_make_val(values[t]) for t in titles)
+                ReportRun.w_insert_row(report_run_id, "", titles, values, {})
+
+    except BaseException:
+        msg = traceback.format_exc()
+        print(msg)
+        if writer is not None:
+            writer.writerow([msg])
+    finally:
+        ReportRun.w_update(report_run_id, "finished")
+        if f is not None:
+            f.close()
+
+
+def do_get(sess):
+    contract_id = req_int("contract_id")
+    months = req_int("months")
+    finish_date = req_date("finish", resolution="month")
+    report_run = ReportRun.insert(
+        sess,
+        "missing_e_bills",
+        g.user,
+        "missing_e_bills",
+        {},
+    )
+    sess.commit()
+    args = g.user.id, report_run.id, contract_id, months, finish_date
+    threading.Thread(target=content, args=args).start()
+    return redirect(f"/report_runs/{report_run.id}", 303)

{chellow-1744710468.0.0 → chellow-1745313690.0.0}/chellow/templates/e/dc_contract.html

@@ -97,7 +97,18 @@
 			<input type="submit" value="Download">
 		</fieldset>
 	</form>
-	<br>
+
+	<form action="/reports/missing_bills">
+		<fieldset>
+			<legend>Download Missing Bills</legend>
+			<input type="hidden" name="contract_id" value="{{dc_contract.id}}">
+			
+			<label>Months</label> <input name="months" value="1" maxlength="2" size="2">
+			<label>Last Month</label> {{input_date('finish', last_month_finish, 'month')}}
+			<input type="submit" value="Download">
+		</fieldset>
+	</form>
+
 	<h3>Script</h3>
 
 	<pre>{{dc_contract.charge_script}}</pre>

{chellow-1744710468.0.0 → chellow-1745313690.0.0}/chellow/templates/e/mop_contract.html

@@ -76,6 +76,17 @@
 			<input type="submit" value="Download"/>
 		</fieldset>
 	</form>
+
+	<form action="/reports/missing_bills">
+		<fieldset>
+			<legend>Download Missing Bills</legend>
+			<input type="hidden" name="contract_id" value="{{contract.id}}">
+			
+			<label>Months</label> <input name="months" value="1" maxlength="2" size="2">
+			<label>Last Month</label> {{input_date('finish', last_month_finish, 'month')}}
+			<input type="submit" value="Download">
+		</fieldset>
+	</form>
 	<br>
 	<h2>Script</h2>
 		<pre>{{contract.charge_script}}</pre>

{chellow-1744710468.0.0 → chellow-1745313690.0.0}/chellow/templates/e/supplier_contract.html

@@ -97,6 +97,17 @@
 		</fieldset>
 	</form>
 
+	<form action="/reports/missing_bills">
+		<fieldset>
+			<legend>Download Missing Bills</legend>
+			<input type="hidden" name="contract_id" value="{{contract.id}}">
+			
+			<label>Months</label> <input name="months" value="1" maxlength="2" size="2">
+			<label>Last Month</label> {{input_date('finish', month_finish, 'month')}}
+			<input type="submit" value="Download">
+		</fieldset>
+	</form>
+
 	<h2>Script</h2>	
 
 	<pre>{{contract.charge_script}}</pre>