def test_evaluate_profitable():
    market = Market('test', 0, '', 'SingleMarket')
    c1 = Contract('test', 'test1', '')
    c2 = Contract('test', 'test2', '')
    c3 = Contract('test', 'test3', '')

    c1.short_offers = [ Offer(c1, 'NO', .4, 10) ]
    c2.short_offers = [ Offer(c2, 'NO', .6, 10) ]
    c3.short_offers = [ Offer(c3, 'NO', .8, 10) ]


    market.contracts = [ c1, c2, c3 ]

    r = buy_no.evaluate(market)
    
    assert r is not None

    ret = r[0]
    gain = r[1]
    cost = r[2]
    shares = r[3]

    assert cost == 18
    assert shares == 10
    assert round(ret, 2) == .1
    assert round(gain, 2) == 1.8
Esempio n. 2
0
    def dbinit(self):
        # Currencies
        currencies = {}
        currencies["BTC"] = Currency(key_name="BTC",
                                     name="Bitcoin",
                                     symbol="BTC")
        currencies["USD"] = Currency(key_name="USD",
                                     name="US Dollar",
                                     symbol=u"$")
        currencies["EUR"] = Currency(key_name="EUR", name="Euro", symbol=u"€")
        currencies["SEK"] = Currency(key_name="SEK",
                                     name="Swedish Kronor",
                                     symbol="kr")
        for currency in currencies:
            currencies[currency].put()

        # Markets
        markets = {}
        markets["KapitonSEK"] = Market(key_name="KapitonSEK",
                                       name="Kapiton",
                                       url="http://kapiton.se/",
                                       currency=currencies["SEK"],
                                       fee=0.0135)
        markets["MtGoxEUR"] = Market(key_name="MtGoxEUR",
                                     name="MtGox",
                                     url="http://mtgox.com/",
                                     currency=currencies["EUR"],
                                     fee=0.006)
        markets["MtGoxUSD"] = Market(key_name="MtGoxUSD",
                                     name="MtGox",
                                     url="http://mtgox.com/",
                                     currency=currencies["USD"],
                                     fee=0.006)
        for market in markets:
            markets[market].put()
Esempio n. 3
0
def market_update(currency):
    market_response = requests.request("GET", market_url).json()['result']
    # Create a new variable to instantiate the api.
    isFound = False
    # crypto-currency is set to not being in the database.
    for item in market_response:
        if item["MarketName"] == currency.coin_pair:
            # if the
            isFound = True
            coin_ticker = item['MarketCurrency']
            coin_base = item['BaseCurrency']
            coin_name = item['MarketCurrencyLong']
            coin_pair = item['MarketName']
            coin_active = item['IsActive']
            coin_created = item['Created']
            coin_logo = item['LogoUrl']

            Market.create(coin_ticker=coin_ticker,
                          coin_base=coin_base,
                          coin_name=coin_name,
                          coin_pair=coin_pair,
                          coin_active=coin_active,
                          coin_created=coin_created,
                          coin_logo=coin_logo,
                          currency_id=currency.id).save()
            break
    if not isFound:
        Market.create(currency_id=currency.id).save()
def test_evaluate_profitable():
    market = Market("test", 0, "", "SingleMarket")
    c1 = Contract("test", "test1", "")
    c2 = Contract("test", "test2", "")
    c3 = Contract("test", "test3", "")

    c1.long_offers = [Offer(c1, "YES", 0.1, 10)]
    c2.long_offers = [Offer(c2, "YES", 0.2, 10)]
    c3.long_offers = [Offer(c3, "YES", 0.3, 10)]

    market.contracts = [c1, c2, c3]

    r = buy_yes.evaluate(market)

    assert r is not None

    ret = r[0]
    gain = r[1]
    cost = r[2]
    shares = r[3]

    assert cost == 6
    assert shares == 10
    assert round(ret, 2) == 0.6
    assert round(gain, 2) == 4
Esempio n. 5
0
def create_Market(name, nickname, neighborhood, city, number):
    newMarket = Market(
        name=name.lower(), nickname=nickname.lower(), neighborhood=neighborhood.lower(), city=city.lower()
    )
    newMarket.save()
    update_query = Number.update(market=newMarket).where(Number.number == number)
    update_query.execute()
    return newMarket
Esempio n. 6
0
def create_tables():
    Number.create_table(True)
    SMS.create_table(True)
    Seller.create_table(True)
    Market.create_table(True)
    List.create_table(True)
    ListRelationship.create_table(True)
    Outbox.create_table(True)
def test_evaluate_notprofitable():
    market = Market('test', 0, '', 'SingleMarket')
    c1 = Contract('test', 'test1', '')

    c1.long_offers = [ Offer(c1, 'YES', .52, 10) ]
    c1.short_offers = [ Offer(c1, 'NO', .54, 5)]


    market.contracts = [ c1 ]

    r = buy_yes_no.evaluate(market)
    
    assert r is None
def test_evaluate_notprofitable():
    market = Market("test", 0, "", "SingleMarket")
    c1 = Contract("test", "test1", "")
    c2 = Contract("test", "test2", "")
    c3 = Contract("test", "test3", "")

    c1.long_offers = [Offer(c1, "YES", 0.4, 10)]
    c2.long_offers = [Offer(c2, "YES", 0.5, 10)]
    c3.long_offers = [Offer(c3, "YES", 0.6, 10)]

    market.contracts = [c1, c2, c3]

    r = buy_yes.evaluate(market)

    assert r is None
def test_evaluate_notprofitable():
    market = Market('test', 0, '', 'SingleMarket')
    c1 = Contract('test', 'test1', '')
    c2 = Contract('test', 'test2', '')
    c3 = Contract('test', 'test3', '')

    c1.short_offers = [ Offer(c1, 'NO', .9, 10) ]
    c2.short_offers = [ Offer(c2, 'NO', .95, 10) ]
    c3.short_offers = [ Offer(c3, 'NO', .99, 10) ]


    market.contracts = [ c1, c2, c3 ]

    r = buy_no.evaluate(market)
    
    assert r is None
Esempio n. 10
0
 def currency_names(self):
     currencies = []
     markets = Market.select()
     for market in markets:
         currencies.append(market.coin_name)
         currencies.append(market.coin_pair)
     return currencies
Esempio n. 11
0
 def get(self):
     user = User.select().where(User.id == int(self.current_user)).get()
     names = self.currency_names()
     # get user's portfolio based off of slug in url
     userMarkets = UserCurrency.select().where(
         UserCurrency.user_id == user.id)
     bitcoin = Currency.select().where(
         Currency.coin_pair == "USDT-BTC").get()
     # set bitcoin as variable in order to render the price on the index page.
     if not userMarkets:
         market = Market.select().join(Currency).where(
             Currency.coin_pair == "USDT-BTC").get()
         return self.render_template("dashboard.html", {
             "user": user,
             "market": market,
             "bitcoin": bitcoin,
             'names': names
         })
     return self.render_template(
         "dashboard.html", {
             "user": user,
             "bitcoin": bitcoin,
             "userMarkets": userMarkets,
             'names': names
         })
Esempio n. 12
0
 def get(self,id):
     try:
         market = Market.get(Market.id == id)
     except Exception as e:
         print(e)
         abort(404,message="Not found")
     else:
         return market    
Esempio n. 13
0
 def get(self):
     user = False
     if self.current_user:
         user = int(self.current_user)
     bitcoin = Currency.select().where(Currency.coin_pair == "USDT-BTC").get()
     # set bitcoin as variable in order to render the price on the index page.
     markets = Market.select().join(Currency).where(Currency.id == Market.currency_id).order_by(Currency.volume.desc()).limit(6)
     return self.render_template("index.html", {'markets': markets, "bitcoin": bitcoin, "user": user})
Esempio n. 14
0
def get_stocks_in_day(stock_name, day):
    out = []
    markets = Market.all(keys_only=False).filter("date =", day).filter("ref =", stock_name.market_ref).order('time').fetch(100)
    for market in markets:
        stock = Stock.all().filter("market =", market.key()).filter('name = ', stock_name.key()).get()
        if not stock is None:
            dt = datetime.combine(market.date, market.time)
            out.append((dt, stock, market.exchange_rate))
    return out
Esempio n. 15
0
def get_stocks_days(stock_name, num_days=10):
    days = last_weekdays(num_days)
    out = []
    for day in days:
        market = Market.all(keys_only=False).filter("date =", day.date()).filter("ref =", stock_name.market_ref).order('-time').get()
        if not market is None:
            stock = Stock.all().filter("market =", market.key()).filter('name = ', stock_name.key()).get()
            if not stock is None:
                out.append((day, stock, market.exchange_rate))
    return out
Esempio n. 16
0
def main():
    """
    Application that will...
    """
    gbce = Market()

    # open the market
    print("------------------------------------")
    print("Global Beverage Corporation Exchange")
    print("------------------------------------")

    # load sample stock data into the market
    for stock in SAMPLE_DATA:
        stk = Stock()
        setattr(stk, "Stock Symbol", stock[0])
        setattr(stk, "Type", stock[1])
        setattr(stk, "Last Dividend", stock[2])
        setattr(stk, "Fixed Dividend", stock[3])
        setattr(stk, "Par Value", stock[4])

        gbce.add_stock(stk)
        print("Welcome {} to the GBCE".format(getattr(stk, "Stock Symbol")))
        sleep(0.8)

    # run some trades
    for trade_no in range(20):
        t = Trade()
        setattr(t, "Stock Symbol",
                choice(list(map(lambda x: x[0], SAMPLE_DATA))))
        setattr(t, "Buy/Sell", choice(['Buy', 'Sell']))
        setattr(t, "Quantity",
                choice([500, 1000, 2000, 5000, 10000, 20000, 50000]))
        setattr(t, "Price", choice(list(range(50, 150))))

        gbce.add_trade(t)

        sto = gbce.get_stock(getattr(t, "Stock Symbol"))

        print("{sale_report} ({all_share})".\
              format(sale_report="{time}: {b} {q} shares of {s} for {p}".\
                     format(b=getattr(t,"Buy/Sell"),
                            time=t.Timestamp.time().replace(microsecond=0),
                            q=t.Quantity,p=t.Price,
                            s=getattr(t,"Stock Symbol")),
                     all_share="GBCE All-Share: {a:.2f}".\
                     format(a=gbce.all_share_index())))

        sleep(0.75 + choice([0.10, 0.15, 0.25, 0.45]))

    # close the market
    print("------------------------------------")
Esempio n. 17
0
def get_market():
    #util.clean_market(0)
    url = 'http://pregao-online.bmfbovespa.com.br/Cotacoes.aspx'
    soup = BeautifulSoup(urlfetch.fetch(url, deadline=50).content, 'lxml')
    rate = util.get_exchange()
    #dt = get_datetime()
    dt = datetime.datetime.now(tz.tzstr('EBST3EBDT'))

    market = Market(ref=0, date=dt.date(), time=dt.time(), exchange_rate=rate)
    market.put()

    table = soup('table', attrs={'id': 'ctl00_DefaultContent_GrdCarteiraIndice'})[0]
    for tr in table('tr')[1:]:
        tds = tr('td')
        code = str(tds[0].string)
        name = util.clean_string(tds[1].string)
        value = util.get_float(tds[2].string)
        diff = util.get_float(tds[3].text.strip())
        stock = Stock(name=util.get_or_create_name(0, code, name),
                      value=value, diff=diff, market=market.key())
        stock.put()
Esempio n. 18
0
def get_market():
    #util.clean_market(1)
    #dt = get_datetime()
    dt = datetime.datetime.now(tz.tzstr('EST5EDT'))
    market = Market(ref=1, date=dt.date(), time=dt.time())
    market.put()

    url = 'http://www.barchart.com/stocks/nasdaq100.php?view=main'
    soup = BeautifulSoup(urlfetch.fetch(url, deadline=30).content, 'lxml')
    table = soup('table', attrs={'id': 'dt1'})[0]

    for tr in table('tr')[1:]:
        tds = tr('td')
        code = str(tds[0].text)
        name = str(tds[1].text)
        value = float(tds[2].text.replace(',', ''))
        text_replace = tds[4].text.replace(',', '').replace('%', '')
        diff = float(text_replace) if text_replace != 'unch' else 0.0
        stock = Stock(name=util.get_or_create_name(1, code, name),
                      value=value, diff=diff, market=market.key())
        stock.put()
Esempio n. 19
0
def parse_cyb2(
    url='http://www.szse.cn/szseWeb/FrontController.szse?randnum=0.5328349224291742'
):
    payload = {
        'ACTIONID': 7,
        'AJAX': 'AJAX-TRUE',
        'CATALOGID': '1898_nm',
        'TABKEY': 'tab1',
        'txtQueryDate': '2016-01-15',
        'REPORT_ACTION': 'reach'
    }
    res = requests.post(url, data=payload)
    print res.text
    # read html <table> to list of DataFrame
    dfs = pd.read_html(res.text, flavor='lxml')
    # dfs = pd.read_html(etree.tostring(r), flavor='bs4')
    if len(dfs) >= 1:
        df = dfs[0]
        print df
        tradable_shares = df.iloc[4][1]
        total_market = df.iloc[5][1]
        volume_money = df.iloc[7][1]
        volume = df.iloc[8][1]
        pe = df.iloc[10][1]
        high_pe = df.iloc[10][3]
        value = df.iloc[13][1]

        if isinstance(tradable_shares, type(pd.NaT)):
            tradable_shares = 0
        if type(total_market) == type(pd.NaT):
            total_market = 0
        if isinstance(volume_money, type(pd.NaT)):
            volume_money = 0
        if isinstance(volume, type(pd.NaT)):
            volume = 0
        if isinstance(pe, type(pd.NaT)):
            pe = 0
        if type(value) != float:
            value = 0.0

        # 换手率=成交量÷当日实际流通量
        if tradable_shares == 0:
            turnover = 0
        else:
            turnover = float(volume) / float(tradable_shares)
        print 'name:{} total_market:{} volume:{} turnover:{} pe:{} value:{}'.format(
            name, total_market, volume_money, turnover, pe, value)
        market = Market(name,
                        float(total_market) / 100000000,
                        float(volume_money) / 100000000, turnover, pe, value)
        print market
        return market
Esempio n. 20
0
 def scrape(self, limit=None):
     soup = BeautifulSoup(self.text, 'lxml')
     table = soup.find('table', attrs={'id': TABLE_ID})
     coins = []
     for row in table.find_all('tr')[1:]:
         tds = row.find_all('td')
         props = [td.get_text().strip() for td in tds]
         icon = tds[1].find('img')
         props.append(icon['src'] if icon else '')
         coins.append(Coin(props))
         if limit and len(coins) == limit:
             break
     return Market(coins)
def test_evaluate_profitable():
    market = Market('test', 0, '', 'SingleMarket')
    c1 = Contract('test', 'test1', '')

    c1.long_offers = [ Offer(c1, 'YES', .4, 10) ]
    c1.short_offers = [ Offer(c1, 'NO', .4, 5)]

    market.contracts = [ c1 ]

    r = buy_yes_no.evaluate(market)
    
    assert r is not None

    ret = r[0]
    gain = r[1]
    cost = r[2]
    shares = r[3]

    assert shares == 5
    assert cost == 4
    assert round(ret, 2) == .23
    assert round(gain, 2) == 1
Esempio n. 22
0
def parse_sz_market_common(name, url):
    page = parse(url).getroot()
    result = etree.tostring(page)
    # print '*'*20
    # print result
    # print '*'*20

    r = page.get_element_by_id('REPORTID_tab1')
    print '*' * 20
    print etree.tostring(r)
    print '*' * 20
    # read html <table> to list of DataFrame
    dfs = pd.read_html(etree.tostring(r), flavor='lxml')
    # dfs = pd.read_html(etree.tostring(r), flavor='bs4')
    if len(dfs) >= 1:
        df = dfs[0]
        print df
        tradable_shares = df.iloc[4][1]
        total_market = df.iloc[5][1]
        volume_money = df.iloc[7][1]
        volume = df.iloc[8][1]
        pe = df.iloc[10][1]
        high_pe = df.iloc[10][3]
        value = df.iloc[13][1]

        if isinstance(tradable_shares, type(pd.NaT)):
            tradable_shares = 0
        if type(total_market) == type(pd.NaT):
            total_market = 0
        if isinstance(volume_money, type(pd.NaT)):
            volume_money = 0
        if isinstance(volume, type(pd.NaT)):
            volume = 0
        if isinstance(pe, type(pd.NaT)):
            pe = 0
        if type(value) != float:
            value = 0.0

        # 换手率=成交量÷当日实际流通量
        if tradable_shares == 0:
            turnover = 0
        else:
            turnover = float(volume) / float(tradable_shares)
        print 'name:{} total_market:{} volume:{} turnover:{} pe:{} value:{}'.format(
            name, total_market, volume_money, turnover, pe, value)
        market = Market(name,
                        float(total_market) / 100000000,
                        float(volume_money) / 100000000, turnover, pe, value)
        print market
        return market
Esempio n. 23
0
 def post(self):
     userID = int(self.current_user)
     currencyName = self.get_body_argument("currencyName")
     market = Market.select().where((Market.coin_pair == currencyName) | (Market.coin_name == currencyName)).get()
     markets = UserCurrency.select().where(UserCurrency.market_id == market.id)
     if not markets:
         userCurr = UserCurrency.create(user_id=userID,
                                        market_id=market.id,
                                        currency_id=market.id)
         userCurr.save()
     elif markets:
         for user in markets:
             if user.user_id != userID:
                 userCurr = UserCurrency.create(user_id=userID,
                                                 market_id=market.id,
                                                 currency_id=market.id)
                 userCurr.save()
     return self.redirect("/dashboard")
Esempio n. 24
0
def parse_sh_market():
    page = parse(
        'http://www.sse.com.cn/market/stockdata/overview/day/').getroot()
    result = etree.tostring(page)
    print result

    r = page.get_element_by_id('dateList')
    statistics = r.text_content().split()
    for word in statistics:
        print word

    market = Market(name='sh',
                    total_market_cap=statistics[1],
                    volume=float(statistics[8]) / 10000,
                    turnover=statistics[12],
                    pe=statistics[14],
                    date=statistics[2])
    print market
    return market
Esempio n. 25
0
def parse_sz_market():
    page = parse('http://www.szse.cn/main/marketdata/tjsj/jbzb/').getroot()

    r = page.get_element_by_id('REPORTID_tab1')
    print etree.tostring(r)
    # read html <table> to list of DataFrame
    dfs = pd.read_html(etree.tostring(r), flavor='lxml')
    # print dfs
    # print len(dfs)
    if len(dfs) >= 1:
        df = dfs[0]
        print df
        total_market = df.iloc[10][1]
        volume = df.iloc[12][1]
        avg_price = df.iloc[13][1]
        pe = df.iloc[14][1]
        turnover_rate = df.iloc[15][1]

        if type(total_market) == type(pd.NaT):
            total_market = 0
        if type(volume) == type(pd.NaT):
            volume = 0
        if type(turnover_rate) == type(pd.NaT):
            turnover_rate = 0
        if type(pe) == type(pd.NaT):
            pe = 0
        print 'total_market:{} volume:{} turnover_rate:{} pe:{}'.format(
            total_market, volume, turnover_rate, pe)
        market = Market('sz',
                        total_market_cap=float(total_market) / 100000000,
                        volume=float(volume) / 100000000,
                        turnover=float(turnover_rate),
                        pe=float(pe))
        print market
        # print df.index
        # print df.columns
        # print df.values
        # print df.describe()
        return market
Esempio n. 26
0
    def setUp(self):
        """Create test client, add sample data."""

        User.query.delete()
        Market.query.delete()
        SavedArticle.query.delete()

        self.client = app.test_client()

        m = Market(code="en-CA", name="United States")

        db.session.add(m)
        db.session.commit()

        self.testuser = User(email="*****@*****.**",
                             username="******",
                             password="******",
                             image_url="http://www.picture.com",
                             market="en-CA")

        db.session.add(self.testuser)
        db.session.commit()
Esempio n. 27
0
def index(password):
    print >> sys.stderr, "within index"
    try:
        if password == PASSWORD:
            print >> sys.stderr, "within try"
            sellerList = Seller.select()
            smsList = SMS.select()
            numberList = Number.select()
            l = List.select()
            marketList = Market.select()
            lrList = ListRelationship.select()
            outboxList = Outbox.select()
            return render_template("index.html", title = 'TABLES', sellerList = sellerList, smsList = smsList, l = l, marketList = marketList)
            #return 'hello world'
        else:
            print >> sys.stderr, "wrong password"
    except:
        print >> sys.stderr, "within except"
        print >> sys.stderr, str(sys.exc_info()[0]) # These write the nature of the error
        print >> sys.stderr, str(sys.exc_info()[1])
        statement = 'An exception has Occured'+ str(sys.exc_type) + '[' + str(sys.exc_value) + ']'
        return statement
Esempio n. 28
0
from models import Market
import datetime

from lxml import html
import requests

from models import db

raw = requests.get("https://loanbase.com/stats")
tree = html.fromstring(raw.text)

active_loans = float(
    tree.xpath('//div[@class="statistic"]/p//text()')[2].split(" ")[1])

m = Market(lbactive=active_loans, created=datetime.datetime.utcnow())
db.session.add(m)
db.session.commit()
Esempio n. 29
0
def get_market(ref, date=None, keys_only=False):
    if date is None:
        return Market.all(keys_only=keys_only).filter("ref =", ref).order('-date').order('-time').get()
    else:
        return Market.all(keys_only=keys_only).filter("date =", date.date()).filter("time =", date.time()).filter("ref =", ref).get()
Esempio n. 30
0
def get_last_date(market_ref):
    return Market.all().filter("ref = ", market_ref).order('-date').get().date
def test_evaluate_empty_market():
    market = Market("test", 0, "", "SingleMarket")
    market.contracts = []

    r = buy_yes.evaluate(market)
    assert r is None
def test_evaluate_empty_market():
    market = Market('test', 0, '', 'SingleMarket')
    market.contracts = []

    r = buy_yes_no.evaluate(market)
    assert (r is None)
Esempio n. 33
0
def get_markets(db_session, betfair_api, event):

    markets = []
    bfl_markets = betfair_api.betting.list_market_catalogue(
        filter=bfl.filters.market_filter(
            event_ids=[event.betfair_id],
            market_type_codes=['WIN'],
        ),
        max_results=25,
        market_projection=['MARKET_START_TIME', 'RUNNER_METADATA'])
    for bfl_market in bfl_markets:
        market = db_session.query(Market).filter(
            Market.event_id == event.id,
            Market.betfair_id == bfl_market.market_id).one_or_none()
        if not market:
            print(
                f"New market: {bfl_market.market_start_time}: {bfl_market.market_name} ({len(bfl_market.runners)} runners)"
            )
            market = Market(event_id=event.id,
                            betfair_id=bfl_market.market_id,
                            name=bfl_market.market_name,
                            start_time=bfl_market.market_start_time,
                            total_matched=bfl_market.total_matched)
            db_session.add(market)
        markets.append(market)
        for bfl_runner in bfl_market.runners:
            runner = db_session.query(Runner).filter(
                Runner.betfair_id == bfl_runner.selection_id).one_or_none()
            if not runner:
                runner = Runner(
                    betfair_id=bfl_runner.selection_id,
                    name=bfl_runner.runner_name,
                )
                db_session.add(runner)
            market_runner = db_session.query(MarketRunner).filter(
                MarketRunner.market_id == market.id,
                MarketRunner.runner_id == runner.id).one_or_none()
            if not market_runner:
                market_runner = MarketRunner(
                    market_id=market.id,
                    runner_id=runner.id,
                    sort_priority=bfl_runner.sort_priority)
                jockey_name = bfl_runner.metadata['JOCKEY_NAME']
                if jockey_name:
                    jockey = db_session.query(Jockey).filter(
                        Jockey.name == jockey_name).one_or_none()
                    if not jockey:
                        jockey = Jockey(name=jockey_name, )
                        db_session.add(jockey)
                    market_runner.jockey_id = jockey.id
                trainer_name = bfl_runner.metadata['TRAINER_NAME']
                if trainer_name:
                    trainer = db_session.query(Trainer).filter(
                        Trainer.name == trainer_name).one_or_none()
                    if not trainer:
                        trainer = Trainer(name=trainer_name, )
                        db_session.add(trainer)
                    market_runner.trainer_id = trainer.id
                db_session.add(market_runner)
    db_session.commit()
    return markets
Esempio n. 34
0
def forecast():
    #tam & sas
    sales = request.form['sales']
    price = request.form['price']
    sas = request.form['sas']
    growth = request.form['growth']
    total = Market(sales, price, sas, growth)
    calc_tam = total.tam()
    calc_tam_c = '{:,.2f}'.format(calc_tam)
    calc_sas = total.sas()
    calc_sas_c = '{:,.2f}'.format(calc_sas)
    #forecast P&L inputs
    salesm1 = request.form['salesm1']
    pricem1 = request.form['pricem1']
    sgmom = request.form['sgmom']
    cmgrowth = request.form['cmgrowth']
    pindex = request.form['pindex']
    cogs = request.form['cogs']
    opex = request.form['opex']
    fixed = request.form['fixed']
    #forecast P&L class constructor
    fpl = Forecastpl(salesm1, pricem1, sgmom, cmgrowth, pindex, cogs, opex,
                     fixed)
    #x chart axis
    x = np.arange(1, 13)
    #forecast P&L growth and percentages
    fpl.sales_growth()
    fpl.cm_growth()
    fpl.price_growth()
    fpl.cogs_pc()
    fpl.opex_pc()
    fpl.fixed_pc()
    #forecast P&L pre-plot calculations
    fpl.units_mom()
    fpl.price_mom()
    fpl_rev = fpl.revenue_profile()
    fpl.cm_calc_initial()
    fpl.cm_adjusted()
    fpl_cmadj = fpl.cm_calc()
    fpl.fixed_calc()
    fpl_op = fpl.fpl_op_profit()
    #forecast P&L cumulative
    fpl_rev_cum = np.cumsum(fpl_rev)
    fpl_cmadj_cum = np.cumsum(fpl_cmadj)
    fpl_op_cum = np.cumsum(fpl_op)
    #sas and fp&l comparison
    fpl_sas = round(np.sum(fpl_rev, dtype=np.float64), 2)
    fpl_sas_c = '{:,.2f}'.format(fpl_sas)
    fpl_sas_delta = round(float(fpl_sas - calc_sas), 2)
    fpl_sas_delta_c = '{:,.2f}'.format(fpl_sas_delta)
    fpl_sas_delta_pc = round(float((fpl_sas / calc_tam) * 100), 2)
    #plot parameters
    plt.plot(x, fpl_rev_cum, label='revenue')
    plt.plot(x, fpl_cmadj_cum, label='cm')
    plt.plot(x, fpl_op_cum, label='op profit')
    plt.xlabel('month')
    plt.ylabel('£')
    plt.title('Forecast P&L cumulative ')
    plt.legend()
    plt.xticks(x)
    plt.savefig(img_path)
    plt.close()
    return render_template('forecast.html',
                           sales=sales,
                           price=price,
                           sas=sas,
                           growth=growth,
                           calc_tam_c=calc_tam_c,
                           calc_sas_c=calc_sas_c,
                           name='Forecast P&L cumulative',
                           fpl_sas_c=fpl_sas_c,
                           fpl_sas_delta_c=fpl_sas_delta_c,
                           fpl_sas_delta_pc=fpl_sas_delta_pc,
                           fileName=fileName,
                           fileExt=fileExt)