def on_start_up(ctx): if sys.platform.startswith('java'): jython_start(ctx) else: cpython_start() Monad.getUtils()['impt'](globals(), *LIBS) for lib_name in LIBS: try: globals()[lib_name].startup() except AttributeError: pass
from net.sf.chellow.monad import Monad import StringIO import sys import os import db import utils import templater import hh_importer Monad.getUtils()['impt']( globals(), 'db', 'utils', 'templater', 'general_import', 'hh_importer') Contract = db.Contract UserException = utils.UserException render = templater.render inv, template = globals()['inv'], globals()['template'] def make_fields(sess, contract, message=None): messages = None if message is None else [str(message)] return { 'contract': contract, 'processes': hh_importer.get_hh_import_processes(contract.id), 'messages': messages} sess = None contract = None try: sess = db.session() hh_importer_contract = Contract.get_non_core_by_name(sess, 'hh_importer') if inv.getRequest().getMethod() == 'GET': hhdc_contract_id = inv.getLong('hhdc_contract_id')
def get_lib(lib_name): return Monad.getContext().getAttribute("net.sf.chellow." + lib_name)
import sys from net.sf.chellow.monad import Monad import utils import db Monad.getUtils()['impt'](globals(), 'utils', 'db') inv, template = globals()['inv'], globals()['template'] hh_format = utils.hh_format if sys.platform.startswith('java'): from java.awt.image import BufferedImage from javax.imageio import ImageIO from java.awt import Color, Font from java.lang import System import math import datetime import pytz from dateutil.relativedelta import relativedelta HH = utils.HH Site = db.Site colour_list = [ Color.BLUE, Color.GREEN, Color.RED, Color.YELLOW, Color.MAGENTA, Color.CYAN, Color.PINK, Color.ORANGE] def set_colour(graphics, supplies, id): graphics.setColor(supplies[id][0]) def add_colour(supplies, id, name, source_code): if id not in supplies: supplies[id] = [len(supplies), name, source_code]
from net.sf.chellow.monad import Monad import time import traceback import utils import db import hh_importer import bsuos import system_price import bank_holidays import rcrc import tlms import dloads Monad.getUtils()['impt']( globals(), 'utils', 'hh_importer', 'bsuos', 'rcrc', 'tlms', 'db', 'system_price', 'bank_holidays', 'dloads') UserException = utils.UserException def on_shut_down(ctx): messages = [] sess = None try: sess = db.session() for md in ( hh_importer, bsuos, system_price, rcrc, tlms, bank_holidays, dloads): try: md.shutdown() except UserException, e: time.sleep(2)
from net.sf.chellow.monad import Monad import datetime import os import traceback import threading import pytz from dateutil.relativedelta import relativedelta from sqlalchemy import or_ from sqlalchemy.sql.expression import null import db import utils import computer import dloads import sys Monad.getUtils()['impt']( globals(), 'templater', 'db', 'utils', 'computer', 'dloads') inv = globals()['inv'] Site, Era, Bill = db.Site, db.Era, db.Bill HH, hh_after, hh_format = utils.HH, utils.hh_after, utils.hh_format totalseconds = utils.totalseconds caches = {} year = inv.getInteger("finish_year") month = inv.getInteger("finish_month") months = inv.getInteger("months") if inv.hasParameter('site_id'): st_id = inv.getLong('site_id') else: st_id = None
from net.sf.chellow.monad import Monad import db import system_price_elexon import templater import utils Monad.getUtils()['impt']( globals(), 'utils', 'templater', 'db', 'system_price_elexon') Contract = db.Contract render = templater.render inv, template = globals()['inv'], globals()['template'] sess = None importer = None try: sess = db.session() if inv.getRequest().getMethod() == "GET": importer = system_price_elexon.get_importer() contract = Contract.get_non_core_by_name(sess, 'system_price_elexon') render(inv, template, {'importer': importer, 'contract': contract}) else: importer = system_price_elexon.get_importer() contract = Contract.get_non_core_by_name(sess, 'system_price_elexon') importer.go() inv.sendSeeOther("/reports/385/output/") except utils.UserException, e: sess.rollback() render( inv, template, { 'messages': [str(e)], 'importer': importer, 'contract': contract}) finally: if sess is not None:
from net.sf.chellow.monad import Monad import datetime import pytz from dateutil.relativedelta import relativedelta from sqlalchemy import or_, and_ import traceback import utils import db Monad.getUtils()["impt"](globals(), "utils", "db") HH, hh_format = utils.HH, utils.hh_format RegisterRead, Bill, Supply, Era = db.RegisterRead, db.Bill, db.Supply, db.Era inv = globals()["inv"] year = inv.getInteger("end_year") month = inv.getInteger("end_month") months = inv.getInteger("months") if inv.hasParameter("supply_id"): supply_id = inv.getLong("supply_id") else: supply_id = None def content(): sess = None try: sess = db.session() finish_date = datetime.datetime(year, month, 1, tzinfo=pytz.utc) + relativedelta(months=1) - HH
from net.sf.chellow.monad import Monad import traceback import collections import pytz import threading import sys import os import os.path import time import datetime import utils Monad.getUtils()['impt'](globals(), 'db', 'utils', 'templater') UserException = utils.UserException if sys.platform.startswith('java'): download_path = Monad.getContext().getRealPath("/downloads") else: import chellow download_path = os.path.join(chellow.app.instance_path, 'downloads') if not os.path.exists(download_path): os.makedirs(download_path) download_id = 0 lock = threading.Lock() files = sorted(os.listdir(download_path), reverse=True)
import os import traceback import sys from net.sf.chellow.monad import Monad import utils Monad.getUtils()['impt'](globals(), 'computer', 'db', 'utils', 'triad', 'duos') UserException = utils.UserException inv = globals()['inv'] name = inv.getString("name") head, name = os.path.split(os.path.normcase(os.path.normpath(name))) if sys.platform.startswith('java'): download_path = Monad.getContext().getRealPath("/downloads") else: import chellow download_path = os.path.join(chellow.app.instance_path, 'downloads') full_name = os.path.join(download_path, name) method = inv.getRequest().getMethod() if method == 'GET': def content(): fl = None try: fl = open(full_name) for line in fl: yield line except:
from net.sf.chellow.monad import Monad import templater import db import hh_importer Monad.getUtils()["impt"](globals(), "db", "utils", "templater", "hh_importer") render = templater.render inv, template = globals()["inv"], globals()["template"] sess = None try: sess = db.session() contract_id = inv.getLong("hhdc_contract_id") contract = db.Contract.get_hhdc_by_id(sess, contract_id) process_id = inv.getLong("process_id") process = hh_importer.get_hh_import_processes(contract_id)[process_id] render(inv, template, {"contract": contract, "process": process}) finally: if sess is not None: sess.close()
from net.sf.chellow.monad import Monad import pytz import datetime from sqlalchemy import or_ from sqlalchemy.sql.expression import null import traceback import utils import db import computer import duos import triad Monad.getUtils()["impt"](globals(), "computer", "db", "utils", "triad", "duos") HH, hh_format = utils.HH, utils.hh_format Site, SiteEra, Era, Supply = db.Site, db.SiteEra, db.Era, db.Supply Source, Channel = db.Source, db.Channel inv = globals()["inv"] caches = {} if inv.hasParameter("site_id"): site_id = inv.getLong("site_id") else: site_id = None year = inv.getInteger("year") def content(): sess = None try: sess = db.session()
from net.sf.chellow.monad import Monad import scenario Monad.getUtils()["impt"](globals(), "scenario") db_id = globals()["db_id"] create_future_func = scenario.make_create_future_func_simple("aahedc", ["aahedc_gbp_per_gsp_kwh"]) def hh(supply_source): bill = supply_source.supplier_bill rate_set = supply_source.supplier_rate_sets["aahedc-rate"] try: supply_source.caches["aahedc"] except KeyError: supply_source.caches["aahedc"] = {} try: future_funcs = supply_source.caches["future_funcs"] except KeyError: future_funcs = {} supply_source.caches["future_funcs"] = future_funcs try: future_funcs[db_id] except KeyError: future_funcs[db_id] = {"start_date": None, "func": create_future_func(1, 0)} for hh in supply_source.hh_data: bill["aahedc-msp-kwh"] += hh["msp-kwh"]
from decimal import Decimal from net.sf.chellow.monad import Monad import utils import edi_lib Monad.getUtils()["impt"](globals(), "db", "utils", "templater", "bill_import", "edi_lib") hh_after = utils.hh_after read_type_map = {"00": "N", "01": "E", "02": "E", "04": "C", "06": "X", "07": "N"} class Parser: def __init__(self, f): self.parser = edi_lib.EdiParser(f) self.line_number = None def make_raw_bills(self): raw_bills = [] for self.line_number, code in enumerate(self.parser): if code == "CLO": cloc = self.parser.elements[0] account = cloc[1] elif code == "BCD": ivdt = self.parser.elements[0] invn = self.parser.elements[2] btcd = self.parser.elements[5] reference = invn[0] bill_type_code = btcd[0] issue_date = self.parser.to_date(ivdt[0]) elif code == "MHD":
from net.sf.chellow.monad import Monad import scenario Monad.getUtils()['impt'](globals(), 'scenario') db_id = globals()['db_id'] create_future_func = scenario.make_create_future_func_simple( 'ro', ['gbp_per_msp_kwh']) def hh(supply_source): bill = supply_source.supplier_bill rate_set = supply_source.supplier_rate_sets['ro-rate'] try: supply_source.caches['ro'] except KeyError: supply_source.caches['ro'] = {} try: future_funcs = supply_source.caches['future_funcs'] except KeyError: future_funcs = {} supply_source.caches['future_funcs'] = future_funcs try: future_funcs[db_id] except KeyError: future_funcs[db_id] = { 'start_date': None, 'func': create_future_func(1, 0)} for hh in supply_source.hh_data:
from net.sf.chellow.monad import Monad import db import templater import utils import bank_holidays Monad.getUtils()['impt']( globals(), 'db', 'utils', 'templater', 'bank_holidays') Contract = db.Contract render = templater.render UserException = utils.UserException inv, template = globals()['inv'], globals()['template'] sess = None importer = None try: sess = db.session() if inv.getRequest().getMethod() == "GET": importer = bank_holidays.get_importer() contract = Contract.get_non_core_by_name(sess, 'bank_holidays') render(inv, template, {'importer': importer, 'contract': contract}) else: importer = bank_holidays.get_importer() contract = Contract.get_non_core_by_name(sess, 'bank_holidays') importer.go() inv.sendSeeOther("/reports/221/output/") except UserException, e: sess.rollback() render( inv, template, { 'messages': [str(e)], 'importer': importer, 'contract': contract}) finally:
import db import utils import computer import csv import dloads import StringIO import threading import odswriter import sys CATEGORY_ORDER = { None: 0, 'unmetered': 1, 'nhh': 2, 'amr': 3, 'hh': 4} Monad.getUtils()['impt']( globals(), 'templater', 'db', 'utils', 'computer', 'bsuos', 'aahedc', 'dloads', 'ccl', 'system_price') Site, Era, Bill, SiteEra = db.Site, db.Era, db.Bill, db.SiteEra Contract, Supply, Source = db.Contract, db.Supply, db.Source HhDatum, Channel = db.HhDatum, db.Channel MarketRole = db.MarketRole HH, hh_after, hh_format = utils.HH, utils.hh_after, utils.hh_format totalseconds, UserException = utils.totalseconds, utils.UserException hh_before, form_int = utils.hh_before, utils.form_int SupplySource = computer.SupplySource inv = globals()['inv'] base_name = [] now = datetime.datetime.now(pytz.utc)
from net.sf.chellow.monad import Monad import db import templater import utils import system_price Monad.getUtils()["impt"](globals(), "db", "utils", "templater", "system_price") Contract = db.Contract render = templater.render UserException = utils.UserException inv, template = globals()["inv"], globals()["template"] sess = None importer = None try: sess = db.session() if inv.getRequest().getMethod() == "GET": importer = system_price.get_importer() contract = Contract.get_non_core_by_name(sess, "system_price") render(inv, template, {"importer": importer, "contract": contract}) else: importer = system_price.get_importer() contract = Contract.get_non_core_by_name(sess, "system_price") importer.go() inv.sendSeeOther("/reports/381/output/") except UserException, e: sess.rollback() render(inv, template, {"messages": [str(e)], "importer": importer, "contract": contract}) finally: if sess is not None: sess.close()
from net.sf.chellow.monad import Monad import datetime import os import shutil import StringIO import tarfile import templater import dloads import utils Monad.getUtils()['impt'](globals(), 'utils', 'templater', 'dloads') render = templater.render inv, template = globals()['inv'], globals()['template'] def make_fields(lib_path, message=None): messages = [] if message is None else [str(message)] files = [] for fl in sorted(os.listdir(lib_path)): full_file = os.path.join(lib_path, fl) statinfo = os.stat(full_file) files.append( { 'name': fl, 'last_modified': datetime.datetime.utcfromtimestamp( statinfo.st_mtime), 'size': statinfo.st_size, 'creation_date': datetime.datetime.utcfromtimestamp( statinfo.st_ctime)}) mem_items = dloads.get_mem_items() mem_keys = sorted(mem_items.keys())
from net.sf.chellow.monad import Monad import db import templater Monad.getUtils()["impt"](globals(), "templater", "db") Contract = db.Contract inv, template = globals()["inv"], globals()["templater"] sess = None try: sess = db.session() contract_id = inv.getLong("mop_contract_id") contract = Contract.get_mop_by_id(contract_id) templater.render(inv, template, {"contract": contract}) finally: if sess is not None: sess.close()
from java.io import StringWriter, InputStreamReader from net.sf.chellow.monad import Hiber, Monad, MonadMessage from java.lang.management import ManagementFactory from com.jezhumble.javasysmon import JavaSysMon from net.sf.chellow.billing import Contract source, doc = globals()["source"], globals()["doc"] interrupt_id = None if inv.getRequest().getMethod() == "POST": if inv.hasParameter("interrupt"): interrupt_id = inv.getLong("thread-id") Monad.getUtils()["imprt"]( globals(), { "db": ["HhDatum", "Site", "Supply", "set_read_write", "session"], "utils": ["UserException", "HH", "form_date"], "templater": ["render", "on_start_report", "get_report"], }, ) elif inv.hasParameter("run_shutdown"): shutdown_contract = Contract.getNonCoreContract("shutdown") shutdown_contract.callFunction("on_shut_down", [Monad.getContext()]) source.appendChild(MonadMessage("Shut down successfully.").toXml(doc)) elif inv.hasParameter("run_startup"): startup_contract = Contract.getNonCoreContract("startup") startup_contract.callFunction("on_start_up", [Monad.getContext()]) elif inv.hasParameter("cancel_backend"): backend_pid = inv.getLong("backend_pid") con = Hiber.session().connection()
from net.sf.chellow.monad import Monad import datetime import pytz from sqlalchemy import or_ from sqlalchemy.sql.expression import null from dateutil.relativedelta import relativedelta import traceback import utils import db import computer Monad.getUtils()['impt'](globals(), 'computer', 'db', 'utils') inv, template = globals()['inv'], globals()['template'] hh_before, HH, hh_format = utils.hh_before, utils.HH, utils.hh_format form_int = utils.form_int Contract, Era = db.Contract, db.Era caches = {} end_year = form_int(inv, "end_year") end_month = form_int(inv, "end_month") months = form_int(inv, "months") contract_id = form_int(inv, 'hhdc_contract_id') def content(): sess = None try: sess = db.session() contract = Contract.get_hhdc_by_id(sess, contract_id)
from net.sf.chellow.monad import Monad from dateutil.relativedelta import relativedelta from sqlalchemy.sql.expression import null from sqlalchemy import or_ import utils import db import triad_rates import computer import duos Monad.getUtils()['impt']( globals(), 'db', 'utils', 'templater', 'computer', 'duos', 'triad_rates') HH, hh_after = utils.HH, utils.hh_after Contract, RateScript = db.Contract, db.RateScript db_id = globals()['db_id'] def triad_calc( bill, prefix, triad_data, financial_year_start, financial_year_finish, data_source, month_begin): gsp_kw = 0 for i, triad_hh in enumerate(triad_data): triad_prefix = prefix + '-' + str(i + 1) bill[triad_prefix + '-date'] = triad_hh['hist-start'] bill[triad_prefix + '-msp-kw'] = triad_hh['msp-kw'] bill[triad_prefix + '-status'] = triad_hh['status'] bill[triad_prefix + '-laf'] = triad_hh['laf'] bill[triad_prefix + '-gsp-kw'] = triad_hh['gsp-kw'] gsp_kw += triad_hh['gsp-kw'] bill[prefix + '-gsp-kw'] = gsp_kw / 3
from net.sf.chellow.monad import Monad import db import bill_import import templater import utils Monad.getUtils()['impt'](globals(), 'db', 'utils', 'templater', 'bill_import') Batch = db.Batch inv, template = globals()['inv'], globals()['template'] render = templater.render UserException = utils.UserException def make_fields(sess, importer, message=None): messages = None if message is None else [str(message)] batch = Batch.get_by_id(sess, importer.batch_id) fields = {'batch': batch, 'messages': messages} if importer is not None: imp_fields = importer.make_fields() if 'successful_bills' in imp_fields and \ len(imp_fields['successful_bills']) > 0: fields['successful_max_registers'] = \ max( len(bill['reads']) for bill in imp_fields[ 'successful_bills']) fields.update(imp_fields) fields['status'] = importer.status() return fields sess = None try:
import traceback from net.sf.chellow.monad import Monad from sqlalchemy import or_ from sqlalchemy.sql.expression import null, true import db import utils import computer Monad.getUtils()["impt"](globals(), "db", "utils", "templater", "computer") inv = globals()["inv"] Supply, Era, Site, SiteEra = db.Supply, db.Era, db.Site, db.SiteEra HH, hh_format = utils.HH, utils.hh_format caches = {} supply_id = inv.getLong("supply_id") start_date = utils.form_date(inv, "start") finish_date = utils.form_date(inv, "finish") file_name = "supply_virtual_bills_hh_" + str(supply_id) + ".csv" def content(): sess = None try: sess = db.session() supply = Supply.get_by_id(sess, supply_id) forecast_date = computer.forecast_date() prev_titles = None
from net.sf.chellow.monad import Monad import db import utils import templater Monad.getUtils()['impt'](globals(), 'db', 'utils', 'templater') Source, GeneratorType, GspGroup = db.Source, db.GeneratorType, db.GspGroup Era, Supply = db.Era, db.Supply UserException, form_date = utils.UserException, utils.form_date render = templater.render inv, template = globals()['inv'], globals()['template'] def make_fields(sess, supply, message=None): messages = [] if message is None else [str(message)] sources = sess.query(Source).order_by(Source.code) generator_types = sess.query(GeneratorType).order_by(GeneratorType.code) gsp_groups = sess.query(GspGroup).order_by(GspGroup.code) eras = sess.query(Era).filter( Era.supply == supply).order_by(Era.start_date.desc()) return { 'supply': supply, 'messages': messages, 'sources': sources, 'generator_types': generator_types, 'gsp_groups': gsp_groups, 'eras': eras} sess = None try: sess = db.session() if inv.getRequest().getMethod() == 'GET': supply_id = inv.getLong('supply_id') supply = Supply.get_by_id(sess, supply_id) render(inv, template, make_fields(sess, supply))
from net.sf.chellow.monad import Monad import datetime import pytz import utils import db import computer import scenario Monad.getUtils()["impt"](globals(), "db", "utils", "computer", "scenario") HH = utils.HH Contract = db.Contract db_id = globals()["db_id"] create_future_func = scenario.make_create_future_func_simple("ccl", ["ccl_rate"]) def ccl(data_source): rate_set = data_source.supplier_rate_sets["ccl-rate"] if data_source.supply.find_era_at(data_source.sess, data_source.finish_date + HH) is None: sup_end = data_source.finish_date else: sup_end = None try: cache = data_source.caches["ccl"] except: data_source.caches["ccl"] = {} cache = data_source.caches["ccl"] try: