Exemple #1
0
def code_summary_chart(line):
    final = gen_summary()
    
    
    filename = 'img_chart_summary.png'
    chart(final, filename, value2desc)
    return r'\includegraphics[totalheight=0.4\textheight]{%s}' % filename
Exemple #2
0
    def generate_gui(self, config):
        self.title('Entropia')

        self.geometry(
            str(self.frames_numbers * 55 + 460) + 'x' +
            str((self.frames_numbers) * 50 + 80))

        # self.frame_start = self.generate_frames()
        self.frame_start = Frame(master=self, background='#F3E77F')
        self.frame_start.pack(side=LEFT, fill=Y)

        self.frame_start.place(x=1,
                               y=1,
                               width=self.frames_numbers * 50,
                               height=80)

        self.container = Container(self, config['Container'], config['Atom'])

        self.generate_buttons()

        self.chart = chart(self)
        self.chart.place(y=80,
                         x=self.frames_numbers * 51,
                         width=600,
                         height=400)
        self.chart.pack(side=RIGHT, fill=Y)
        self.resizable(False, False)
def run(args):
    col_num = get_col_num(args.c)
    file_iter =  (l.rstrip("\r\n").split("\t")
                  for l in open(args.file) if l[0] != "#")

    pvals = np.array([float(b[col_num]) for b in file_iter])
    kwargs = {"bins": args.n} if args.n else {}
    hist, bins = np.histogram(pvals, normed=True, **kwargs)
    xlabels = "|".join("%.2f-%.2f" % b for b in pairwise(bins))
    print "#", chart(hist, xlabels)
    hist, bins = np.histogram(pvals, normed=False, **kwargs)

    print "# median: %.3f mean:%.3f; std: %.3f min:%.3f; max:%.3f" % (
        np.median(pvals), pvals.mean(), pvals.std(), pvals.min(), pvals.max())

    try:
        from scipy.stats import chisquare
        chisq, p = chisquare(hist)
        print "#chi-square test of uniformity. p: %.3g " \
              "(low value means reject null of uniformity)" % p
    except ImportError:
        pass
    print "#bin_start\tbin_end\tn"
    for bin, val in zip(pairwise(bins), hist):
        print "%.2f\t%.2f\t%i" % (bin[0], bin[1], val)
Exemple #4
0
def chart_from_colony(idcolony, idspectrum_selected=None):
    "returns a chart object given a colony id"
    from session import session
    from chart import chart
    from series import series

    from table_spectrum import t_spectrum
    data = t_spectrum.get_cursor_data(field_names=("spectrum.id", "spectrum.idcolony", "series.vector", "flag_inactive"), \
        iddomain=session.iddomain, idcolony=idcolony, idexperiment=session.idexperiment, iddeact=session.iddeact)

    ch = chart()

    i = 0
    for (idspectrum, idcolony, vector, flag_inactive) in data:
        se = series()
        if vector == None:
            se.y_values = []
        else:
            se.y_values = str2vector(vector)

        se.color = session.get_spectrum_color(i)
        if not flag_inactive:
            pass
        else:
            se.line_style = "Dot"
        if idspectrum_selected and idspectrum == idspectrum_selected:
            se.flag_selected = True
        ch.bind_series(se)

        i += 1

    return ch
Exemple #5
0
def code_results_chart(line):
    #global results
    #
    ##parts = line.split()
    ##method = parts[-2]
    ##testdata = parts[-1]
    #
    #data = process_results(results, method, testdata)
    
    final, method, testdata = do_code_results(line)
    
    #print data
    
    filename = 'img_chart_%s.png' % method
    chart(final, filename, value2desc)
    return r'\includegraphics[totalheight=0.4\textheight]{%s}' % filename
Exemple #6
0
    def plot(self, bundles=None, settings=None, twinx=False, show=True, **kwargs):
        #print "SETTINGS", settings
        from chart import chart

        self.process(**kwargs)

        #print self.settings

        if bundles != None:
            diff = len(self.datasets) - len(bundles)
            if diff > 0:
                bundles += [dict(bundles[-1]) for _ in range(diff)]
        else:
            import chart_config as cc
            bundles = [dict(cc._bundle) for _ in range(len(self.datasets))]

        # if settings != None:
        #     for default,new in zip(self.settings, settings):
        #         default.update(new)

        #print self.settings
        _twinx = len(self.datasets) % 2 == 0

        #print len(self.datasets), len(bundles), settings

        # if len(self.charts) == 0:
            ##print "Calculate charts"

        if _twinx and twinx:
            for i in range(0, len(self.datasets), 2):
                d_one = self.datasets[i]
                d_two = self.datasets[i+1]
                b_one = bundles[i]
                b_two = bundles[i+1]
                c = chart([d_one, d_two], self.settings.pop(0))
                #print "Twinxing!"
                c.plot([b_one, b_two], twinx=twinx, show=show, **kwargs)
                self.charts.append(c)

        else:
            for d_set,bundle,settings in zip(self.datasets, bundles, self.settings):
                c = chart([d_set], settings)
                c.plot(bundle, twinx=False, show=show, **kwargs)
                self.charts.append(c)
Exemple #7
0
    def plotperformance_last_12_month(self,Data,date,area):
        file_name_xml   = 'performance_last_12_month.xml'
        
        t0  = date.replace(year=date.year-1)
        consumo_array   =   []
        for r in range(13):
            if date.month+r>12:
                date_r  =   t0.replace(year=date.year,month=date.month+r-12,day=1)
            else:
                date_r  =   t0.replace(year=date.year-1,month=date.month+r,day=1)
                
            
            """dato ya viene correctamente escalado"""
            if r==12:
                consumo_array.append({'perf_area':float(Data[r])/area,\
                                      'datetimestamp':date_r,\
                                      'Style':'current'})
            else:
                consumo_array.append({'perf_area':float(Data[r])/area,\
                                      'datetimestamp':date_r,\
                                      'Style':'previous'})
            
        
            
        """configuracion de ploteo y sus formatos deveberian estan en un archivo a parte"""

        scale           = {'major_interval':1,
                       'major_interval_unit': 'Month', \
                       'minor_interval':1, \
                       'minor_interval_unit': 'Day',\
                       'xmin': '%s' % t0, \
                       'xmax': '%s' % date, \
                       'ymin':0,\
                       'ymax':40000,\
                       'autoscale':'on'}
        
        labels          =   ['Desempeno por area ultimos 12 meses','Kwh/m2','Hora','m3/hr','m3/hr']
        
        formatos        = {'xinputformat':'%yyyy-%MM-%dd %HH:%mm:%ss',\
                       'xlabelformat':'{%Value}{dateTimeFormat: %MMM}',\
                       'tooltipformat':'Valor: {%YValue}{numDecimals:0}Kwh',\
                       'ylabelformat':'{%Value}{numDecimals:0}',\
                       'y2labelformat':'{%Value}{numDecimals:0}',\
                       'y3labelformat':'{%Value}{numDecimals:0}'}
        
        Series_to_plot  = ['perf_area']

        chart1          = chart('%s/viewer/Date-Time-Bar.xml'%abs_path)

        chart1.xml_process(data=[consumo_array], Series_to_plot=Series_to_plot, scale=scale, \
                           Titles=labels, formatos=formatos,integral=[0,0,0],timeformat='year')
        
        chart1.save_file('%s%s'%(self.path_to_save,file_name_xml))
        
        
Exemple #8
0
    def plotperformance_last_12_month(self, Data, date, area):
        file_name_xml = 'performance_last_12_month.xml'

        t0 = date.replace(year=date.year - 1)
        consumo_array = []
        for r in range(13):
            if date.month + r > 12:
                date_r = t0.replace(year=date.year,
                                    month=date.month + r - 12,
                                    day=1)
            else:
                date_r = t0.replace(year=date.year - 1,
                                    month=date.month + r,
                                    day=1)
            """dato ya viene correctamente escalado"""
            if r == 12:
                consumo_array.append({'perf_area':float(Data[r])/area,\
                                      'datetimestamp':date_r,\
                                      'Style':'current'})
            else:
                consumo_array.append({'perf_area':float(Data[r])/area,\
                                      'datetimestamp':date_r,\
                                      'Style':'previous'})
        """configuracion de ploteo y sus formatos deveberian estan en un archivo a parte"""

        scale           = {'major_interval':1,
                       'major_interval_unit': 'Month', \
                       'minor_interval':1, \
                       'minor_interval_unit': 'Day',\
                       'xmin': '%s' % t0, \
                       'xmax': '%s' % date, \
                       'ymin':0,\
                       'ymax':40000,\
                       'autoscale':'on'}

        labels = [
            'Desempeno por area ultimos 12 meses', 'Kwh/m2', 'Hora', 'm3/hr',
            'm3/hr'
        ]

        formatos        = {'xinputformat':'%yyyy-%MM-%dd %HH:%mm:%ss',\
                       'xlabelformat':'{%Value}{dateTimeFormat: %MMM}',\
                       'tooltipformat':'Valor: {%YValue}{numDecimals:0}Kwh',\
                       'ylabelformat':'{%Value}{numDecimals:0}',\
                       'y2labelformat':'{%Value}{numDecimals:0}',\
                       'y3labelformat':'{%Value}{numDecimals:0}'}

        Series_to_plot = ['perf_area']

        chart1 = chart('%s/viewer/Date-Time-Bar.xml' % abs_path)

        chart1.xml_process(data=[consumo_array], Series_to_plot=Series_to_plot, scale=scale, \
                           Titles=labels, formatos=formatos,integral=[0,0,0],timeformat='year')

        chart1.save_file('%s%s' % (self.path_to_save, file_name_xml))
    def order_execution(self, curr, direction, size, target, stop, id, current_price, digits):
        if direction == 'sell':
            size = -size
        
        #if date_trade == dt.datetime.now().date():
        #     order = xxx
        # else:
        #     orderid = len(self.orders) + len(self.trades) + 1
        #     order = (orderid, curr, size, target, stop)

        order = self.handle.order(curr, size, target, stop)


        self.plan.get(id).update({
                                'try_qty': self.plan[id]['try_qty'] - 1
                                })

        self.orders.update({id:{
            'asset': curr,
            'entry_date': dt.datetime.now(tz=pytz.timezone("Europe/Moscow")).date(), #date_trade.date()
            'entry_time': dt.datetime.now(tz=pytz.timezone("Europe/Moscow")).time(), #date_trade.time()
            'orderID': int(order[0].order.orderId),
            'tradeID': 0,
            'targetID': 0,
            'stopID': 0,
            'entry_price': current_price, 
            'current_price': current_price,
            'qty': size,
            'target': target,
            'stop': stop,
            'unrealizedPL': 0,
            'strat': self.plan.get(id)['strat'],
            'direction': self.plan.get(id)['direction'],
            'strat_cond': self.plan.get(id)['strat_cond'],
            'strat_name': self.plan.get(id)['strat_name'],
            'commission': 0
        }})


        pd.to_pickle(self.orders, f'./DATA/orders/orders_{dt.datetime.now(tz=pytz.timezone("Europe/Moscow")).date()}') #date_trade

        chart(self.plan, id, curr, (self.current_time()+100), dt.datetime.now(tz=pytz.timezone("Europe/Moscow")).date())
Exemple #10
0
def write_acf(acf_vals, out):
    # write acf to a file and return only [((lag_min, lag_max), corr)...]
    simple_acf = []
    values = [float(v[0]) for k, v in acf_vals]
    xlabels = "|".join("%s-%s" % k for k, v in acf_vals)
    print >>out, "#", chart(values, xlabels)
    print >> out, "#lag_min\tlag_max\tcorrelation\tN\tp"
    for k, v in sorted(acf_vals):
        print >> out, "%i\t%i\t%.4g\t%i\t%.4g" % (k[0], k[1], v[0], v[1], v[2])
        simple_acf.append((k, v[0]))
    return simple_acf
Exemple #11
0
    def __init__(self, mx, spurs, fef, parent=None):
        QMainWindow.__init__(self, parent)

        self.mx = mx
        self.spurset = spurs
        self.fef = fef

        self.chart = chart(self.spurset, self.fef)
        self.create_menu_bar()
        self.create_main_frame()
        self.hookup()
    def order_process(self, order, id, curr, size):

        self.plan.get(id).update(
        {
            'try_qty': self.plan[id]['try_qty'] - 1
            }
            )

        self.orders.update({id:{
            'asset': curr,
            'date': pd.to_datetime(order.get('orderFillTransaction').get('time').split('T')[0]).date(),
            'entry_time': pd.to_datetime((str(int(order.get('orderFillTransaction').get('time').split('T')[1][0:2]) + 3)) +':'+ order.get('orderFillTransaction').get('time').split('T')[1][3:5]).time(),
            'tradeID': order.get('relatedTransactionIDs')[1],
            'entry_price': order.get('orderFillTransaction').get('price'),
            'qty': size,
            'target': order.get('orderCreateTransaction').get('takeProfitOnFill')['price'],
            'stop': order.get('orderCreateTransaction').get('stopLossOnFill')['price'],
            'margin': order.get('orderFillTransaction').get('tradeOpened')['initialMarginRequired'],
            'unrealizedPL': 0,
        }})

        pd.to_pickle(self.orders, f'./DATA/orders/orders_{dt.datetime.now(tz=pytz.timezone("Europe/Moscow")).date()}')

        chart(self.plan, id, curr, (self.current_time()+100), dt.datetime.now(tz=pytz.timezone("Europe/Moscow")).date())
Exemple #13
0
    def order_process(self, order, id, curr, size, strat, others):

        self.plan.get(id).update(
        {
            'try_qty': self.plan[id]['try_qty'] - 1
            }
            )

        try:
            order_time = pd.to_datetime((str(int(order.get('orderFillTransaction').get('time').split('T')[1][0:2]) + 3)) +':'+ order.get('orderFillTransaction').get('time').split('T')[1][3:5]).time()
        except Exception as e:
            print(str(e) + ' on order_process()')
            logging.error(str(e))
            order_time = dt.datetime.now(tz=pytz.timezone('Europe/Moscow')).time()
    
        self.orders.update({id:{

            'asset': curr,
            'date': pd.to_datetime(order.get('orderFillTransaction').get('time').split('T')[0]).date(),
            'entry_time': order_time,
            'tradeID': order.get('relatedTransactionIDs')[1],
            'entry_price': order.get('orderFillTransaction').get('price'),
            'qty': size,
            'target': order.get('orderCreateTransaction').get('takeProfitOnFill')['price'],
            'stop': order.get('orderCreateTransaction').get('stopLossOnFill')['price'],
            'margin': order.get('orderFillTransaction').get('tradeOpened')['initialMarginRequired'],
            'intraday_strat': strat,
            'events': cal_list(dt.datetime.now(tz=pytz.timezone("Europe/Moscow"))),
            'unrealizedPL': 0,
            'others': others,

        }})

        pd.to_pickle(self.orders, f'./orders')

        chart(self.plan, id, curr, self.intraday, (self.current_time()+100), dt.datetime.now(tz=pytz.timezone("Europe/Moscow")).date())
Exemple #14
0
#!/usr/bin/env python3

from chart import chart

print('Content-Type; text/html; charset=utf-8')
print('')
print(chart())
    def order_execution(self, curr, direction, size, target, stop, id,
                        current_price, digits, strat, others):
        if direction == 'sell':
            size = -size

        order = self.handle.order(curr, size, target, stop)

        print(
            f"{id} {direction} {curr} at price: {round(current_price, digits)} , target: {round(target, digits)}, stop: {round(stop, digits)}, size: {size}"
        )

        self.plan.get(id).update({'try_qty': self.plan[id]['try_qty'] - 1})

        self.orders.update({
            id: {
                'asset':
                curr,
                'entry_date':
                dt.datetime.now(tz=pytz.timezone("Europe/Moscow")).date(),
                'entry_time':
                dt.datetime.now(tz=pytz.timezone("Europe/Moscow")).time(),
                'orderID':
                int(order[0].order.orderId),
                'tradeID':
                0,
                'targetID':
                0,
                'stopID':
                0,
                'entry_price':
                current_price,
                'current_price':
                current_price,
                'qty':
                size,
                'target':
                target,
                'stop':
                stop,
                'unrealizedPL':
                0,
                'strat':
                self.plan.get(id)['strat'],
                'direction':
                self.plan.get(id)['direction'],
                'strat_cond':
                self.plan.get(id)['strat_cond'],
                'strat_name':
                self.plan.get(id)['strat_name'],
                'intraday_strat':
                strat,
                'events':
                cal_list(dt.datetime.now(tz=pytz.timezone("Europe/Moscow"))),
                'commission':
                0,
                'others':
                others,
            }
        })

        pd.to_pickle(self.orders, f'./orders')

        chart(self.plan, id, curr, self.intraday, (self.current_time() + 100),
              dt.datetime.now(tz=pytz.timezone("Europe/Moscow")).date())
Exemple #16
0
    def plotprofile_kw(self, timeformat, date, Elec_Tools_handler):

        import calendar
        power_array = []

        if timeformat == 'week':
            t0 = date.replace(
                day=date.day, hour=0, minute=0, second=0,
                microsecond=0) - datetime.timedelta(days=date.weekday() + 7)
            t1 = date.replace(
                day=date.day, hour=0, minute=0, second=0,
                microsecond=0) - datetime.timedelta(days=date.weekday())
            t2 = date.replace(
                day=date.day, hour=23, minute=59, second=59,
                microsecond=0) + datetime.timedelta(
                    days=6) - datetime.timedelta(days=date.weekday())
        elif timeformat == 'month' and date.month == 1:
            t0 = date.replace(year=date.year - 1,
                              month=12,
                              day=1,
                              hour=0,
                              minute=0,
                              second=0,
                              microsecond=0) - datetime.timedelta(
                                  days=date.replace(year=date.year - 1,
                                                    month=12,
                                                    day=1,
                                                    hour=0,
                                                    minute=0,
                                                    second=0,
                                                    microsecond=0).weekday())
            t1 = date.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
            t2 = date.replace(
                year=date.year,
                month=1,
                day=calendar.mdays[1],
                hour=23,
                minute=59,
                second=59,
                microsecond=0) + datetime.timedelta(
                    days=6 - date.replace(year=date.year - 1,
                                          month=12,
                                          day=1,
                                          hour=0,
                                          minute=0,
                                          second=0,
                                          microsecond=0).weekday())
        elif timeformat == 'month':
            t0 = date.replace(month=date.month - 1,
                              day=1,
                              hour=0,
                              minute=0,
                              second=0,
                              microsecond=0) - datetime.timedelta(
                                  days=date.replace(month=date.month - 1,
                                                    day=1,
                                                    hour=0,
                                                    minute=0,
                                                    second=0,
                                                    microsecond=0).weekday())
            t1 = date.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
            t2 = date.replace(
                day=calendar.mdays[date.month],
                hour=23,
                minute=59,
                second=59,
                microsecond=0) + datetime.timedelta(
                    days=6 - date.replace(day=calendar.mdays[date.month],
                                          hour=23,
                                          minute=59,
                                          second=59,
                                          microsecond=0).weekday())
        elif timeformat == 'year' and date.month == 1:
            t0 = date.replace(year=date.year - 1,
                              month=1,
                              day=1,
                              hour=0,
                              minute=0,
                              second=0,
                              microsecond=0)
            t1 = date.replace(month=1,
                              day=1,
                              hour=0,
                              minute=0,
                              second=0,
                              microsecond=0)
            t2 = date.replace(
                month=12,
                day=calendar.mdays[12],
                hour=23,
                minute=59,
                second=59,
                microsecond=0) + datetime.timedelta(
                    days=6 - date.replace(year=date.year - 1,
                                          month=12,
                                          day=1,
                                          hour=0,
                                          minute=0,
                                          second=0,
                                          microsecond=0).weekday())
        elif timeformat == 'year':
            t0 = date.replace(month=date.month - 1,
                              day=1,
                              hour=0,
                              minute=0,
                              second=0,
                              microsecond=0) - datetime.timedelta(
                                  days=date.replace(year=date.year - 1,
                                                    month=12,
                                                    day=1,
                                                    hour=0,
                                                    minute=0,
                                                    second=0,
                                                    microsecond=0).weekday())
            t1 = date.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
            t2 = date.replace(
                day=calendar.mdays[date.month],
                hour=23,
                minute=59,
                second=59,
                microsecond=0) + datetime.timedelta(
                    days=6 - date.replace(year=date.year - 1,
                                          month=12,
                                          day=1,
                                          hour=0,
                                          minute=0,
                                          second=0,
                                          microsecond=0).weekday())
        elif timeformat == 'report_power_month':
            t0 = date.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
            t1 = t0
            t2 = date.replace(day=calendar.mdays[date.month],
                              hour=0,
                              minute=0,
                              second=0,
                              microsecond=0)

        period = {'week':{'t0':t0,\
                          't1':t1,\
                          't2':t2,\
                          'date':'%s - %s'%((t1).strftime("%d/%m"),t2.strftime("%d/%m"))},\
                  'month':{'t0':t0,\
                           't1':t1,\
                          't2':t2,\
                          'date':'%s'%t2.strftime("%m/%Y")},\
                  'year':{'t0':date.replace(year=date.year-1,month=1,day=1,hour=0,minute=0,second=0,microsecond=0),\
                          't1':date.replace(month=1,day=1,hour=0,minute=0,second=0,microsecond=0),\
                          't2':date.replace(month=12,day=calendar.mdays[12],hour=23,minute=59,second=59,microsecond=0),\
                          'date':'%s'%t2.strftime("%Y")},\
                  'report_power_month':{'t0':t0,\
                                         't2':t2}
                }

        if timeformat == 'report_power_month':
            analisis_detailed = []
            power_array_PPP = []
            power_array_PP = []
            maximos = {'PPP': {'Value': 0}, 'PP': {'Value': 0}}
            ave_sum_PPP = 0
            ave_sum_PP = 0

            for r in range(calendar.mdays[date.month]):
                date_r = period['report_power_month'][
                    't0'] + datetime.timedelta(days=r)

                analisis_detailed.append(
                    Elec_Tools_handler.demand_analysis(date=date_r,
                                                       type='day'))

                power_array_PPP.append({'PPP':analisis_detailed[r]['PPP']['Value'],\
                                    'datetimestamp':date_r,\
                                    'Style':'current'})
                power_array_PP.append({'PP':analisis_detailed[r]['PP']['Value'],\
                                    'datetimestamp':date_r,\
                                    'Style':'current'})

                if analisis_detailed[r]['PPP']['Value'] > maximos['PPP'][
                        'Value']:
                    maximos['PPP'] = analisis_detailed[r]['PPP']
                if analisis_detailed[r]['PP']['Value'] > maximos['PP']['Value']:
                    maximos['PP'] = analisis_detailed[r]['PP']

                ave_sum_PPP = ave_sum_PPP + analisis_detailed[r]['PPP']['ave']
                ave_sum_PP = ave_sum_PPP + analisis_detailed[r]['PP']['ave']

            maximos['PPP']['ave'] = pretty_print(float(ave_sum_PPP) /
                                                 calendar.mdays[date.month],
                                                 scale=1000000000,
                                                 label=['KW', 'MW'])
            maximos['PP']['ave'] = pretty_print(float(ave_sum_PP) /
                                                calendar.mdays[date.month],
                                                scale=1000000000,
                                                label=['KW', 'MW'])


            scale           = { 'major_interval':1,
                           'major_interval_unit': 'Day', \
                           'minor_interval':1, \
                           'minor_interval_unit': 'Hour',\
                           'xmin': '%s' % period['report_power_month']['t0'], \
                           'xmax': '%s' % period['report_power_month']['t2'], \
                           'ymin':0,\
                           'ymax':40000,\
                           'autoscale':'on'}

            labels = [
                'Perfiles de demandas maximas del mes', 'KW', 'KW', 'm3/hr',
                'm3/hr'
            ]

            formatos        = {'xinputformat':'%yyyy-%MM-%dd %HH:%mm:%ss',\
                           'xlabelformat':'{%Value}{dateTimeFormat: %dd}',\
                           'tooltipformat':'Valor: {%YValue}{numDecimals:0}Kwh',\
                           'ylabelformat':'{%Value}{numDecimals:0}',\
                           'y2labelformat':'{%Value}{numDecimals:0}',\
                           'y3labelformat':'{%Value}{numDecimals:0}'}

        Series_to_plot = ['PPP', 'PP']

        chart1 = chart('%s/viewer/Date-Time-Line-demandas.xml' % abs_path)

        chart1.xml_process(data=[power_array_PPP,power_array_PP], Series_to_plot=Series_to_plot, scale=scale, \
                           Titles=labels, formatos=formatos,integral=[0,0,0],timeformat=timeformat)
        chart1.save_file('%sdemandas_mensual.xml' % (self.path_to_save))

        return maximos
Exemple #17
0
    def plotprofile_kwh(self,
                        timeformat,
                        date,
                        Elec_Tools_handler,
                        method='ajax'):
        # method can be 'ajax' or 'xml'
        import calendar
        max_decimal = 1
        consumo_array = []

        if timeformat == 'week':
            t0 = date.replace(
                day=date.day, hour=0, minute=0, second=0,
                microsecond=0) - datetime.timedelta(days=date.weekday() + 7)
            t1 = date.replace(
                day=date.day, hour=0, minute=0, second=0,
                microsecond=0) - datetime.timedelta(days=date.weekday())
            t2 = date.replace(
                day=date.day, hour=23, minute=59, second=59,
                microsecond=0) + datetime.timedelta(
                    days=6) - datetime.timedelta(days=date.weekday())
        elif timeformat == 'month' and date.month == 1:
            t0 = date.replace(year=date.year - 1,
                              month=12,
                              day=1,
                              hour=0,
                              minute=0,
                              second=0,
                              microsecond=0) - datetime.timedelta(
                                  days=date.replace(year=date.year - 1,
                                                    month=12,
                                                    day=1,
                                                    hour=0,
                                                    minute=0,
                                                    second=0,
                                                    microsecond=0).weekday())
            t1 = date.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
            t2 = date.replace(
                year=date.year,
                month=1,
                day=calendar.mdays[1],
                hour=23,
                minute=59,
                second=59,
                microsecond=0) + datetime.timedelta(
                    days=6 - date.replace(year=date.year - 1,
                                          month=12,
                                          day=1,
                                          hour=0,
                                          minute=0,
                                          second=0,
                                          microsecond=0).weekday())
        elif timeformat == 'month':
            t0 = date.replace(month=date.month - 1,
                              day=1,
                              hour=0,
                              minute=0,
                              second=0,
                              microsecond=0) - datetime.timedelta(
                                  days=date.replace(month=date.month - 1,
                                                    day=1,
                                                    hour=0,
                                                    minute=0,
                                                    second=0,
                                                    microsecond=0).weekday())
            t1 = date.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
            t2 = date.replace(
                day=calendar.mdays[date.month],
                hour=23,
                minute=59,
                second=59,
                microsecond=0) + datetime.timedelta(
                    days=6 - date.replace(day=calendar.mdays[date.month],
                                          hour=23,
                                          minute=59,
                                          second=59,
                                          microsecond=0).weekday())
        elif timeformat == 'year' and date.month == 1:
            t0 = date.replace(year=date.year - 1,
                              month=1,
                              day=1,
                              hour=0,
                              minute=0,
                              second=0,
                              microsecond=0)
            t1 = date.replace(month=1,
                              day=1,
                              hour=0,
                              minute=0,
                              second=0,
                              microsecond=0)
            t2 = date.replace(
                month=12,
                day=calendar.mdays[12],
                hour=23,
                minute=59,
                second=59,
                microsecond=0) + datetime.timedelta(
                    days=6 - date.replace(year=date.year - 1,
                                          month=12,
                                          day=1,
                                          hour=0,
                                          minute=0,
                                          second=0,
                                          microsecond=0).weekday())
        elif timeformat == 'year':
            t0 = date.replace(month=date.month - 1,
                              day=1,
                              hour=0,
                              minute=0,
                              second=0,
                              microsecond=0) - datetime.timedelta(
                                  days=date.replace(year=date.year - 1,
                                                    month=12,
                                                    day=1,
                                                    hour=0,
                                                    minute=0,
                                                    second=0,
                                                    microsecond=0).weekday())
            t1 = date.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
            t2 = date.replace(
                day=calendar.mdays[date.month],
                hour=23,
                minute=59,
                second=59,
                microsecond=0) + datetime.timedelta(
                    days=6 - date.replace(year=date.year - 1,
                                          month=12,
                                          day=1,
                                          hour=0,
                                          minute=0,
                                          second=0,
                                          microsecond=0).weekday())
        elif timeformat == 'report_energy_month':
            t0 = date.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
            t1 = t0
            t2 = date.replace(day=calendar.mdays[date.month],
                              hour=0,
                              minute=0,
                              second=0,
                              microsecond=0)

        period = {'week':{'t0':t0,\
                          't1':t1,\
                          't2':t2,\
                          'date':'%s - %s'%((t1).strftime("%d/%m"),t2.strftime("%d/%m"))},\
                  'month':{'t0':t0,\
                           't1':t1,\
                          't2':t2,\
                          'date':'%s'%t2.strftime("%m/%Y")},\
                  'year':{'t0':date.replace(year=date.year-1,month=1,day=1,hour=0,minute=0,second=0,microsecond=0),\
                          't1':date.replace(month=1,day=1,hour=0,minute=0,second=0,microsecond=0),\
                          't2':date.replace(month=12,day=calendar.mdays[12],hour=23,minute=59,second=59,microsecond=0),\
                          'date':'%s'%t2.strftime("%Y")},\
                  'report_energy_month':{'t0':t0,\
                                         't2':t2}
                }

        if timeformat == 'week':
            file_name_xml = 'grafico_1D.xml'
            for r in range(14):
                date_r = period['week']['t0'] + datetime.timedelta(days=r)
                """dato ya viene correctamente escalado"""
                if r < 7:
                    if method == 'xml':
                        consumo_array.append({'KWH':Elec_Tools_handler.calculo_consumo(date=date_r,type='day')['Total']['Value'],\
                                              'datetimestamp':date_r,\
                                              'Style':'previous'})
                    elif method == 'ajax':

                        consumo_array.append({'KWH':round(Elec_Tools_handler.calculo_consumo(date=date_r,type='day')['Total']['Value'],max_decimal),\
                                              'datetimestamp':date_r.strftime("%Y-%m-%d %H:%M:%S"),\
                                              'Style':'previous'})
                    else:
                        pass
                else:
                    if method == 'xml':
                        consumo_array.append({'KWH':Elec_Tools_handler.calculo_consumo(date=date_r,type='day')['Total']['Value'],\
                                          'datetimestamp':date_r,\
                                          'Style':'current'})
                    elif method == 'ajax':
                        consumo_array.append({'KWH':round(Elec_Tools_handler.calculo_consumo(date=date_r,type='day')['Total']['Value'],max_decimal),\
                                          'datetimestamp':date_r.strftime("%Y-%m-%d %H:%M:%S"),\
                                          'Style':'current'})
                    else:
                        pass
            """configuracion de ploteo y sus formatos deveberian estan en un archivo a parte"""
            if method == 'ajax':
                return consumo_array

            scale           = { 'major_interval':1,
                           'major_interval_unit': 'Day', \
                           'minor_interval':1, \
                           'minor_interval_unit': 'Hour',\
                           'xmin': '%s' % t0, \
                           'xmax': '%s' % t2, \
                           'ymin':0,\
                           'ymax':40000,\
                           'autoscale':'on'}

            labels = [
                'Energia consumida durante cada dia', 'Kwh', 'Hora', 'm3/hr',
                'm3/hr'
            ]

            formatos        = {'xinputformat':'%yyyy-%MM-%dd %HH:%mm:%ss',\
                           'xlabelformat':'{%Value}{dateTimeFormat: %dd-%MM}',\
                           'tooltipformat':'Valor: {%YValue}{numDecimals:0}Kwh',\
                           'ylabelformat':'{%Value}{numDecimals:0}',\
                           'y2labelformat':'{%Value}{numDecimals:0}',\
                           'y3labelformat':'{%Value}{numDecimals:0}'}

        if timeformat == 'month':
            file_name_xml = 'grafico_1D.xml'
            days = t2 - t0
            weeks = (days / 7)
            weeks_num = weeks.days

            print weeks_num
            if weeks_num % 7 > 0:
                weeks_num = weeks_num + 1

            for r in range(weeks_num):
                date_r = period['month']['t0'] + datetime.timedelta(days=(r) *
                                                                    7)
                """dato ya viene correctamente escalado"""
                if date_r < period['month']['t1']:
                    if method == 'xml':
                        consumo_array.append({'KWH':Elec_Tools_handler.calculo_consumo(date=date_r,type='week')['Total']['Value'],\
                                              'datetimestamp':date_r,\
                                              'Style':'previous'})
                    elif method == 'ajax':
                        consumo_array.append({'KWH':round(Elec_Tools_handler.calculo_consumo(date=date_r,type='week')['Total']['Value'],max_decimal),\
                                              'datetimestamp':date_r.strftime("%Y-%m-%d %H:%M:%S"),\
                                              'Style':'previous'})
                else:
                    if method == 'xml':
                        consumo_array.append({'KWH':Elec_Tools_handler.calculo_consumo(date=date_r,type='week')['Total']['Value'],\
                                              'datetimestamp':date_r,\
                                              'Style':'current'})
                    elif method == 'ajax':
                        consumo_array.append({'KWH':round(Elec_Tools_handler.calculo_consumo(date=date_r,type='week')['Total']['Value'],max_decimal),\
                                              'datetimestamp':date_r.strftime("%Y-%m-%d %H:%M:%S"),\
                                              'Style':'current'})
            """configuracion de ploteo y sus formatos deveberian estan en un archivo a parte"""

            if method == 'ajax':
                return consumo_array

            scale           = {'major_interval':1,
                               'major_interval_unit': 'Day', \
                               'minor_interval':1, \
                               'minor_interval_unit': 'Hour',\
                               'xmin': '%s' % t0, \
                               'xmax': '%s' % t2, \
                               'ymin':0,\
                               'ymax':40000,\
                               'autoscale':'on'}

            labels = [
                'Energia consumida por semana', 'Kwh', 'Hora', 'm3/hr', 'm3/hr'
            ]

            formatos        = {'xinputformat':'%yyyy-%MM-%dd %HH:%mm:%ss',\
                               'xlabelformat':'{%Value}{dateTimeFormat:%dd-%MM }',\
                               'tooltipformat':'Valor: {%YValue}{numDecimals:0}Kwh',\
                               'ylabelformat':'{%Value}{numDecimals:0}',\
                               'y2labelformat':'{%Value}{numDecimals:0}',\
                               'y3labelformat':'{%Value}{numDecimals:0}'}

        if timeformat == 'year':
            file_name_xml = 'grafico_1D.xml'
            for r in range(24):
                if r > 11:
                    date_r = period['year']['t0'].replace(
                        year=period['year']['t0'].year + 1, month=r - 11)
                else:
                    date_r = period['year']['t0'].replace(month=r + 1)
                """dato ya viene correctamente escalado"""
                if date_r < period['year']['t1']:
                    if method == 'xml':
                        consumo_array.append({'KWH':Elec_Tools_handler.calculo_consumo(date=date_r,type='month')['Total']['Value'],\
                                              'datetimestamp':date_r,\
                                              'Style':'previous'})
                    elif method == 'ajax':
                        consumo_array.append({'KWH':round(Elec_Tools_handler.calculo_consumo(date=date_r,type='month')['Total']['Value'],max_decimal),\
                                              'datetimestamp':date_r.strftime("%Y-%m-%d %H:%M:%S"),\
                                              'Style':'previous'})
                else:
                    if method == 'xml':
                        consumo_array.append({'KWH':Elec_Tools_handler.calculo_consumo(date=date_r,type='month')['Total']['Value'],\
                                              'datetimestamp':date_r,\
                                              'Style':'current'})
                    elif method == 'ajax':
                        consumo_array.append({'KWH':round(Elec_Tools_handler.calculo_consumo(date=date_r,type='month')['Total']['Value'],max_decimal),\
                                              'datetimestamp':date_r.strftime("%Y-%m-%d %H:%M:%S"),\
                                              'Style':'current'})

            if method == 'ajax':
                return consumo_array
            """configuracion de ploteo y sus formatos deveberian estan en un archivo a parte"""

            scale           = {'major_interval':1,
                           'major_interval_unit': 'Month', \
                           'minor_interval':1, \
                           'minor_interval_unit': 'Day',\
                           'xmin': '%s' % t0, \
                           'xmax': '%s' % t2, \
                           'ymin':0,\
                           'ymax':40000,\
                           'autoscale':'on'}

            labels = [
                'Energia consumida por mes', 'Kwh', 'Hora', 'm3/hr', 'm3/hr'
            ]

            formatos        = {'xinputformat':'%yyyy-%MM-%dd %HH:%mm:%ss',\
                           'xlabelformat':'{%Value}{dateTimeFormat: %MMM}',\
                           'tooltipformat':'Valor: {%YValue}{numDecimals:0}Kwh',\
                           'ylabelformat':'{%Value}{numDecimals:0}',\
                           'y2labelformat':'{%Value}{numDecimals:0}',\
                           'y3labelformat':'{%Value}{numDecimals:0}'}

        if timeformat == 'report_energy_month':
            file_name_xml = 'consumo_diario_mensual.xml'
            for r in range(calendar.mdays[date.month]):
                date_r = period['report_energy_month'][
                    't0'] + datetime.timedelta(days=r)
                consumo_array.append({'KWH':Elec_Tools_handler.calculo_consumo(date=date_r,type='day')['Total']['Value'],\
                                          'datetimestamp':date_r,\
                                          'Style':'current'})

            scale           = { 'major_interval':1,
                           'major_interval_unit': 'Day', \
                           'minor_interval':1, \
                           'minor_interval_unit': 'Hour',\
                           'xmin': '%s' % t0, \
                           'xmax': '%s' % t2, \
                           'ymin':0,\
                           'ymax':40000,\
                           'autoscale':'on'}

            labels = [
                'Energia consumida durante cada dia del mes', 'Kwh', 'Hora',
                'm3/hr', 'm3/hr'
            ]

            formatos        = {'xinputformat':'%yyyy-%MM-%dd %HH:%mm:%ss',\
                           'xlabelformat':'{%Value}{dateTimeFormat: %dd}',\
                           'tooltipformat':'Valor: {%YValue}{numDecimals:0}Kwh',\
                           'ylabelformat':'{%Value}{numDecimals:0}',\
                           'y2labelformat':'{%Value}{numDecimals:0}',\
                           'y3labelformat':'{%Value}{numDecimals:0}'}

            Series_to_plot = ['KWH']

            chart1 = chart('%s/viewer/Date-Time-Bar.xml' % abs_path)

            chart1.xml_process(data=[consumo_array], Series_to_plot=Series_to_plot, scale=scale, \
                           Titles=labels, formatos=formatos,integral=[0,0,0],timeformat=timeformat)
            #print '%s%s'%(self.path_to_save,file_name_xml)
            chart1.save_file('%s%s' % (self.path_to_save, file_name_xml))

            return True

        Series_to_plot = ['KWH']

        chart1 = chart('%s/viewer/Date-Time-Bar.xml' % abs_path)

        chart1.xml_process(data=[consumo_array], Series_to_plot=Series_to_plot, scale=scale, \
                       Titles=labels, formatos=formatos,integral=[0,0,0],timeformat=timeformat)
        #print '%s%s'%(self.path_to_save,file_name_xml)
        chart1.save_file('%s%s' % (self.path_to_save, file_name_xml))

        return True
Exemple #18
0
    def plotdayprofile(self, signal=None, date=None):

        #SELECCION DE DATOS
        t0 = date.replace(hour=0, minute=0,
                          second=0) - datetime.timedelta(days=1)
        t1 = date.replace(hour=0, minute=0, second=0)
        t2 = date.replace(hour=23, minute=59, second=59)

        data_to_process     =   list(Measurements.objects.filter(user= self.user,sensor=Sensors.objects.get(pk=self.sensor_id),\
                                                            datetimestamp__range= (t0,t2)).extra(select=sql_extra_pairs[signal]['sql']).\
                                                            order_by('datetimestamp').values('datetimestamp',sql_extra_pairs[signal]['extra']))

        serie = []

        #print data_to_process
        data_size = len(data_to_process)

        #calculo de potencia
        if signal == 'A_KW' or signal == 'B_KW' or signal == 'C_KW' or signal == 'Total_KW':

            data_to_process[0][signal] = 0
            #print data_to_process[0][signal]

            for r in range(data_size - 1):
                delta_time = (
                    date2num(data_to_process[r + 1]['datetimestamp']) -
                    date2num(data_to_process[r]['datetimestamp'])) * 24
                Power_in_r = float(data_to_process[r + 1][
                    sql_extra_pairs[signal]['extra']]) / (delta_time)

                data_to_process[r + 1][signal] = Power_in_r

        #CONSTRUCCION DE DICT PARA PLOTEO
        for pointer in range(data_size):

            if data_to_process[pointer]['datetimestamp'].replace(
                    tzinfo=None) < t1:
                serie.append({'datetimestamp':data_to_process[pointer]['datetimestamp'],\
                               signal:data_to_process[pointer][sql_extra_pairs[signal]['plot']]*ganancias_dict[signal]['gain'],\
                               'Style':'previous'})
            else:
                serie.append({'datetimestamp':data_to_process[pointer]['datetimestamp'],\
                                    signal:data_to_process[pointer][sql_extra_pairs[signal]['plot']]*ganancias_dict[signal]['gain'],\
                                    'Style':'current'})
        data_to_plot = [serie]  #datos parseados

        #FORMATOS DE ANYCHART
        scale           = { 'major_interval':6,\
                          'major_interval_unit': 'Hour', \
                          'minor_interval':30, \
                          'minor_interval_unit': 'Minute',\
                          'xmin': '%s' % t0, \
                          'xmax': '%s' % t2, \
                          'ymin':0,\
                          'ymax':40000,\
                          'autoscale':'on'}

        formatos        = {'xinputformat':'%yyyy-%MM-%dd %HH:%mm:%ss',\
                           'xlabelformat':'{%Value}{dateTimeFormat:%HH:%mm \n%dd-%MM}',\
                           'tooltipformat':'Valor: {%YValue}{numDecimals:2} \n{%XValue}{dateTimeFormat:%HH:%mm \n%dd-%MM-%yyyy}',\
                           'ylabelformat':'{%Value}{numDecimals:0}',\
                           'y2labelformat':'{%Value}{numDecimals:0}',\
                           'y3labelformat':'{%Value}{numDecimals:0}'}

        Series_to_plot = [signal]  #key de la serie a plotear
        labels = [
            ganancias_dict[signal]['chartTitle'],
            ganancias_dict[signal]['chartLabel'], 'Hora', 'm3/hr', 'm3/hr'
        ]
        chart1 = chart('%s/viewer/Date-Time-Line-3.xml' % abs_path)

        chart1.xml_process(data=data_to_plot, Series_to_plot=Series_to_plot, scale=scale, \
                           Titles=labels, formatos=formatos,integral=[0,0,0],timeformat='daypower')
        chart1.save_file('%sgrafico_1D.xml' % self.path_to_save)
    def order_execution(self, curr, direction, size, target, stop, id,
                        current_price, digits):
        if direction == 'sell':
            size = -size

        order = self.handle.order(curr, size, target, stop)

        print(order)

        self.plan.get(id).update({'try_qty': self.plan[id]['try_qty'] - 1})

        self.orders.update({
            id: {
                'asset':
                curr,
                'entry_date':
                dt.datetime.now(tz=pytz.timezone("Europe/Moscow")).date(),
                'entry_time':
                dt.datetime.now(tz=pytz.timezone("Europe/Moscow")).time(),
                'tradeID':
                0,
                'targetID':
                0,
                'stopID':
                0,
                'entry_price':
                current_price,
                'current_price':
                current_price,
                'qty':
                size,
                'target':
                target,
                'stop':
                stop,
                'unrealizedPL':
                0,
                'strat':
                self.plan.get(id)['strat'],
                'direction':
                self.plan.get(id)['direction'],
                'strat_cond':
                self.plan.get(id)['strat_cond'],
                'strat_name':
                self.plan.get(id)['strat_name'],
                'commission':
                0
            }
        })

        print(
            pd.DataFrame(self.orders.values(), self.orders.keys())[[
                'asset', 'current_price', 'direction', 'entry_date',
                'entry_price', 'entry_time', 'qty', 'stop', 'target',
                'tradeID', 'unrealizedPL'
            ]])

        pd.to_pickle(
            self.orders,
            f'./DATA/orders/orders_{dt.datetime.now(tz=pytz.timezone("Europe/Moscow")).date()}'
        )

        chart(self.plan, id, curr, self.current_time(),
              dt.datetime.now(tz=pytz.timezone("Europe/Moscow")).date())
Exemple #20
0
def sentiment(Data, text, negative, positive, twitter):
    negmessage = [
        Data[0],
        ' Apologies for Trump and his rudeness today. @realDonaldTrump'
    ]
    posmessage = [
        Data[1],
        ' Wow, Donald Trump managed to actually be decent today! @realDonaldTrump'
    ]

    score = analyze(str.lower(text), negative, positive)

    #if positive sentiment
    if (score > 0):
        print(text)
        print(score)

        #if 5 minutes no input to verify, continue with posmessage - change later
        try:
            answer = timer.input_with_timeout(
                "Is this tweet actually positive? Y for yes, N for no: ", 10)
        except timer.TimeoutExpired:
            print(score)
            Data[2] = int(Data[2]) + 1
            Data[0] = int(Data[0]) + 1

            chart(Data[2], Data[3], Data[4])
            photo = open('chart.png', 'rb')
            response = twitter.upload_media(media=photo)
            twitter.update_status(status=posmessage,
                                  media_ids=[response['media_id']])

        if str.lower(answer) == "y":
            print(score)
            Data[2] = int(Data[2]) + 1
            Data[0] = int(Data[0]) + 1

            chart(Data[2], Data[3], Data[4])
            photo = open('chart.png', 'rb')
            response = twitter.upload_media(media=photo)
            twitter.update_status(status=posmessage,
                                  media_ids=[response['media_id']])

        elif str.lower(answer) == "n":
            print(score)
            Data[4] = int(Data[4]) + 1
            Data[1] = int(Data[1]) + 1

            chart(Data[2], Data[3], Data[4])
            photo = open('chart.png', 'rb')
            response = twitter.upload_media(media=photo)
            twitter.update_status(status=negmessage,
                                  media_ids=[response['media_id']])

    #if neutral sentiment
    if (score == 0):
        print(text)
        print(score)

        #if 5 minutes no input to verify, continue with posmessage - change later
        try:
            answer = timer.input_with_timeout(
                "Is this tweet actually neutral? Y for yes, N for no: ", 10)

        except timer.TimeoutExpired:
            print(score)
            Data[3] = int(Data[3]) + 1
            Data[0] = int(Data[0]) + 1

            chart(Data[2], Data[3], Data[4])
            photo = open('chart.png', 'rb')
            response = twitter.upload_media(media=photo)
            twitter.update_status(status=posmessage,
                                  media_ids=[response['media_id']])

        if str.lower(answer) == "y":
            print(score)
            Data[3] = int(Data[3]) + 1
            Data[0] = int(Data[0]) + 1

            chart(Data[2], Data[3], Data[4])
            photo = open('chart.png', 'rb')
            response = twitter.upload_media(media=photo)
            twitter.update_status(status=posmessage,
                                  media_ids=[response['media_id']])

        elif str.lower(answer) == "n":
            print(score)
            Data[4] = int(Data[4]) + 1
            Data[1] = int(Data[1]) + 1

            chart(Data[2], Data[3], Data[4])
            photo = open('chart.png', 'rb')
            response = twitter.upload_media(media=photo)
            twitter.update_status(status=negmessage,
                                  media_ids=[response['media_id']])

    #if negative sentiment
    if (score < 0):
        #if 5 minutes no input to verify, continue with negmessage - change later
        print(text)
        print(score)

        try:
            answer = timer.input_with_timeout(
                "Is this tweet actually negative? Y for yes, N for no, p for neutral: ",
                10)
        except timer.TimeoutExpired:
            print(score)
            Data[4] = int(Data[4]) + 1
            Data[1] = int(Data[1]) + 1

            chart(Data[2], Data[3], Data[4])
            photo = open('chart.png', 'rb')
            response = twitter.upload_media(media=photo)
            twitter.update_status(status=negmessage,
                                  media_ids=[response['media_id']])

        if str.lower(answer) == "y":
            print(score)
            Data[4] = int(Data[4]) + 1
            Data[1] = int(Data[1]) + 1

            chart(Data[2], Data[3], Data[4])
            photo = open('chart.png', 'rb')
            response = twitter.upload_media(media=photo)
            twitter.update_status(status=negmessage,
                                  media_ids=[response['media_id']])

        elif str.lower(answer) == "n":
            print(score)
            Data[2] = int(Data[2]) + 1
            Data[0] = int(Data[0]) + 1

            chart(Data[2], Data[3], Data[4])
            photo = open('chart.png', 'rb')
            response = twitter.upload_media(media=photo)
            twitter.update_status(status=posmessage,
                                  media_ids=[response['media_id']])

        elif str.lower(answer) == "p":
            print(score)
            Data[3] = int(Data[3]) + 1
            Data[0] = int(Data[0]) + 1

            chart(Data[2], Data[3], Data[4])
            photo = open('chart.png', 'rb')
            response = twitter.upload_media(media=photo)
            twitter.update_status(status=posmessage,
                                  media_ids=[response['media_id']])
Exemple #21
0
    def plotprofile_kwh(self,timeformat,date, Elec_Tools_handler,method='ajax'):
        # method can be 'ajax' or 'xml'
        import calendar
        max_decimal =   1
        consumo_array   =   []
        
        if timeformat == 'week':
            t0  =   date.replace(day=date.day,hour=0,minute=0,second=0,microsecond=0)-datetime.timedelta(days=date.weekday()+7)
            t1  =   date.replace(day=date.day,hour=0,minute=0,second=0,microsecond=0)-datetime.timedelta(days=date.weekday())
            t2  =   date.replace(day=date.day,hour=23,minute=59,second=59,microsecond=0)+datetime.timedelta(days=6)-datetime.timedelta(days=date.weekday())
        elif timeformat == 'month' and date.month==1:
            t0  =   date.replace(year=date.year-1,month=12,day=1,hour=0,minute=0,second=0,microsecond=0)-datetime.timedelta(days=date.replace(year=date.year-1,month=12,day=1,hour=0,minute=0,second=0,microsecond=0).weekday())
            t1  =   date.replace(day=1,hour=0,minute=0,second=0,microsecond=0)
            t2  =   date.replace(year=date.year,month=1,day=calendar.mdays[1],hour=23,minute=59,second=59,microsecond=0)+datetime.timedelta(days=6-date.replace(year=date.year-1,month=12,day=1,hour=0,minute=0,second=0,microsecond=0).weekday())
        elif timeformat == 'month':
            t0  =   date.replace(month=date.month-1,day=1,hour=0,minute=0,second=0,microsecond=0)-datetime.timedelta(days=date.replace(month=date.month-1,day=1,hour=0,minute=0,second=0,microsecond=0).weekday())
            t1  =   date.replace(day=1,hour=0,minute=0,second=0,microsecond=0)
            t2  =   date.replace(day=calendar.mdays[date.month],hour=23,minute=59,second=59,microsecond=0)+datetime.timedelta(days=6-date.replace(day=calendar.mdays[date.month],hour=23,minute=59,second=59,microsecond=0).weekday())
        elif timeformat == 'year' and date.month==1:
            t0  =   date.replace(year=date.year-1,month=1,day=1,hour=0,minute=0,second=0,microsecond=0)
            t1  =   date.replace(month=1,day=1,hour=0,minute=0,second=0,microsecond=0)
            t2  =   date.replace(month=12,day=calendar.mdays[12],hour=23,minute=59,second=59,microsecond=0)+datetime.timedelta(days=6-date.replace(year=date.year-1,month=12,day=1,hour=0,minute=0,second=0,microsecond=0).weekday())
        elif timeformat == 'year':
            t0  =   date.replace(month=date.month-1,day=1,hour=0,minute=0,second=0,microsecond=0)-datetime.timedelta(days=date.replace(year=date.year-1,month=12,day=1,hour=0,minute=0,second=0,microsecond=0).weekday())
            t1  =   date.replace(day=1,hour=0,minute=0,second=0,microsecond=0)
            t2  =   date.replace(day=calendar.mdays[date.month],hour=23,minute=59,second=59,microsecond=0)+datetime.timedelta(days=6-date.replace(year=date.year-1,month=12,day=1,hour=0,minute=0,second=0,microsecond=0).weekday())
        elif timeformat == 'report_energy_month':
            t0  =   date.replace(day=1,hour=0,minute=0,second=0,microsecond=0)
            t1  =   t0
            t2  =   date.replace(day=calendar.mdays[date.month],hour=0,minute=0,second=0,microsecond=0)
        
        period = {'week':{'t0':t0,\
                          't1':t1,\
                          't2':t2,\
                          'date':'%s - %s'%((t1).strftime("%d/%m"),t2.strftime("%d/%m"))},\
                  'month':{'t0':t0,\
                           't1':t1,\
                          't2':t2,\
                          'date':'%s'%t2.strftime("%m/%Y")},\
                  'year':{'t0':date.replace(year=date.year-1,month=1,day=1,hour=0,minute=0,second=0,microsecond=0),\
                          't1':date.replace(month=1,day=1,hour=0,minute=0,second=0,microsecond=0),\
                          't2':date.replace(month=12,day=calendar.mdays[12],hour=23,minute=59,second=59,microsecond=0),\
                          'date':'%s'%t2.strftime("%Y")},\
                  'report_energy_month':{'t0':t0,\
                                         't2':t2}
                } 
        
        if timeformat   == 'week':
            file_name_xml   = 'grafico_1D.xml'
            for r in range(14):
                date_r  =   period['week']['t0'] + datetime.timedelta(days=r)
                """dato ya viene correctamente escalado"""
                if r < 7:
                    if method == 'xml':
                        consumo_array.append({'KWH':Elec_Tools_handler.calculo_consumo(date=date_r,type='day')['Total']['Value'],\
                                              'datetimestamp':date_r,\
                                              'Style':'previous'})
                    elif method == 'ajax':
                        
                        consumo_array.append({'KWH':round(Elec_Tools_handler.calculo_consumo(date=date_r,type='day')['Total']['Value'],max_decimal),\
                                              'datetimestamp':date_r.strftime("%Y-%m-%d %H:%M:%S"),\
                                              'Style':'previous'})
                    else:
                        pass
                else:
                    if method == 'xml':
                        consumo_array.append({'KWH':Elec_Tools_handler.calculo_consumo(date=date_r,type='day')['Total']['Value'],\
                                          'datetimestamp':date_r,\
                                          'Style':'current'})
                    elif method == 'ajax':
                        consumo_array.append({'KWH':round(Elec_Tools_handler.calculo_consumo(date=date_r,type='day')['Total']['Value'],max_decimal),\
                                          'datetimestamp':date_r.strftime("%Y-%m-%d %H:%M:%S"),\
                                          'Style':'current'})
                    else:
                        pass
                    
            """configuracion de ploteo y sus formatos deveberian estan en un archivo a parte"""
            if method == 'ajax':
                return consumo_array
            
            scale           = { 'major_interval':1,
                           'major_interval_unit': 'Day', \
                           'minor_interval':1, \
                           'minor_interval_unit': 'Hour',\
                           'xmin': '%s' % t0, \
                           'xmax': '%s' % t2, \
                           'ymin':0,\
                           'ymax':40000,\
                           'autoscale':'on'}

            labels          =   ['Energia consumida durante cada dia','Kwh','Hora','m3/hr','m3/hr']
             
            formatos        = {'xinputformat':'%yyyy-%MM-%dd %HH:%mm:%ss',\
                           'xlabelformat':'{%Value}{dateTimeFormat: %dd-%MM}',\
                           'tooltipformat':'Valor: {%YValue}{numDecimals:0}Kwh',\
                           'ylabelformat':'{%Value}{numDecimals:0}',\
                           'y2labelformat':'{%Value}{numDecimals:0}',\
                           'y3labelformat':'{%Value}{numDecimals:0}'}
        
        if timeformat == 'month':
            file_name_xml   = 'grafico_1D.xml'
            days                =   t2-t0
            weeks               =   (days/7)
            weeks_num           =   weeks.days

            print weeks_num
            if weeks_num%7>0:
                weeks_num = weeks_num+1
            
            
            for r in range(weeks_num):
                date_r  =   period['month']['t0'] + datetime.timedelta(days=(r)*7)
                """dato ya viene correctamente escalado"""
                if date_r < period['month']['t1']:
                    if method == 'xml':
                        consumo_array.append({'KWH':Elec_Tools_handler.calculo_consumo(date=date_r,type='week')['Total']['Value'],\
                                              'datetimestamp':date_r,\
                                              'Style':'previous'})
                    elif method == 'ajax':
                        consumo_array.append({'KWH':round(Elec_Tools_handler.calculo_consumo(date=date_r,type='week')['Total']['Value'],max_decimal),\
                                              'datetimestamp':date_r.strftime("%Y-%m-%d %H:%M:%S"),\
                                              'Style':'previous'})
                else:
                    if method == 'xml':
                        consumo_array.append({'KWH':Elec_Tools_handler.calculo_consumo(date=date_r,type='week')['Total']['Value'],\
                                              'datetimestamp':date_r,\
                                              'Style':'current'})
                    elif method == 'ajax':
                        consumo_array.append({'KWH':round(Elec_Tools_handler.calculo_consumo(date=date_r,type='week')['Total']['Value'],max_decimal),\
                                              'datetimestamp':date_r.strftime("%Y-%m-%d %H:%M:%S"),\
                                              'Style':'current'})
            """configuracion de ploteo y sus formatos deveberian estan en un archivo a parte"""
            
            if method == 'ajax':
                return consumo_array
    
            scale           = {'major_interval':1,
                               'major_interval_unit': 'Day', \
                               'minor_interval':1, \
                               'minor_interval_unit': 'Hour',\
                               'xmin': '%s' % t0, \
                               'xmax': '%s' % t2, \
                               'ymin':0,\
                               'ymax':40000,\
                               'autoscale':'on'}
            
            labels          =   ['Energia consumida por semana','Kwh','Hora','m3/hr','m3/hr']
            
            formatos        = {'xinputformat':'%yyyy-%MM-%dd %HH:%mm:%ss',\
                               'xlabelformat':'{%Value}{dateTimeFormat:%dd-%MM }',\
                               'tooltipformat':'Valor: {%YValue}{numDecimals:0}Kwh',\
                               'ylabelformat':'{%Value}{numDecimals:0}',\
                               'y2labelformat':'{%Value}{numDecimals:0}',\
                               'y3labelformat':'{%Value}{numDecimals:0}'}
            
        if timeformat =='year':
            file_name_xml   = 'grafico_1D.xml'
            for r in range(24):
                if r >11:
                    date_r  =   period['year']['t0'].replace(year=period['year']['t0'].year+1, month=r-11)
                else:
                    date_r  =   period['year']['t0'].replace(month=r+1)
                
                """dato ya viene correctamente escalado"""
                if date_r < period['year']['t1']:
                    if method   == 'xml':
                        consumo_array.append({'KWH':Elec_Tools_handler.calculo_consumo(date=date_r,type='month')['Total']['Value'],\
                                              'datetimestamp':date_r,\
                                              'Style':'previous'})
                    elif method == 'ajax':
                        consumo_array.append({'KWH':round(Elec_Tools_handler.calculo_consumo(date=date_r,type='month')['Total']['Value'],max_decimal),\
                                              'datetimestamp':date_r.strftime("%Y-%m-%d %H:%M:%S"),\
                                              'Style':'previous'})
                else:
                    if method   == 'xml':
                        consumo_array.append({'KWH':Elec_Tools_handler.calculo_consumo(date=date_r,type='month')['Total']['Value'],\
                                              'datetimestamp':date_r,\
                                              'Style':'current'})
                    elif method == 'ajax':
                        consumo_array.append({'KWH':round(Elec_Tools_handler.calculo_consumo(date=date_r,type='month')['Total']['Value'],max_decimal),\
                                              'datetimestamp':date_r.strftime("%Y-%m-%d %H:%M:%S"),\
                                              'Style':'current'})
            
            if method == 'ajax':
                return consumo_array
            
            """configuracion de ploteo y sus formatos deveberian estan en un archivo a parte"""

            scale           = {'major_interval':1,
                           'major_interval_unit': 'Month', \
                           'minor_interval':1, \
                           'minor_interval_unit': 'Day',\
                           'xmin': '%s' % t0, \
                           'xmax': '%s' % t2, \
                           'ymin':0,\
                           'ymax':40000,\
                           'autoscale':'on'}
            
            labels          =   ['Energia consumida por mes','Kwh','Hora','m3/hr','m3/hr']
            
            formatos        = {'xinputformat':'%yyyy-%MM-%dd %HH:%mm:%ss',\
                           'xlabelformat':'{%Value}{dateTimeFormat: %MMM}',\
                           'tooltipformat':'Valor: {%YValue}{numDecimals:0}Kwh',\
                           'ylabelformat':'{%Value}{numDecimals:0}',\
                           'y2labelformat':'{%Value}{numDecimals:0}',\
                           'y3labelformat':'{%Value}{numDecimals:0}'}
            


        if timeformat   == 'report_energy_month':
            file_name_xml   = 'consumo_diario_mensual.xml'
            for r in range(calendar.mdays[date.month]):
                date_r  =   period['report_energy_month']['t0'] + datetime.timedelta(days=r)
                consumo_array.append({'KWH':Elec_Tools_handler.calculo_consumo(date=date_r,type='day')['Total']['Value'],\
                                          'datetimestamp':date_r,\
                                          'Style':'current'})
            
            scale           = { 'major_interval':1,
                           'major_interval_unit': 'Day', \
                           'minor_interval':1, \
                           'minor_interval_unit': 'Hour',\
                           'xmin': '%s' % t0, \
                           'xmax': '%s' % t2, \
                           'ymin':0,\
                           'ymax':40000,\
                           'autoscale':'on'}

            labels          =   ['Energia consumida durante cada dia del mes','Kwh','Hora','m3/hr','m3/hr']
             
            formatos        = {'xinputformat':'%yyyy-%MM-%dd %HH:%mm:%ss',\
                           'xlabelformat':'{%Value}{dateTimeFormat: %dd}',\
                           'tooltipformat':'Valor: {%YValue}{numDecimals:0}Kwh',\
                           'ylabelformat':'{%Value}{numDecimals:0}',\
                           'y2labelformat':'{%Value}{numDecimals:0}',\
                           'y3labelformat':'{%Value}{numDecimals:0}'}
            
            Series_to_plot  = ['KWH']

            chart1          = chart('%s/viewer/Date-Time-Bar.xml'%abs_path)

            chart1.xml_process(data=[consumo_array], Series_to_plot=Series_to_plot, scale=scale, \
                           Titles=labels, formatos=formatos,integral=[0,0,0],timeformat=timeformat)
            #print '%s%s'%(self.path_to_save,file_name_xml)
            chart1.save_file('%s%s'%(self.path_to_save,file_name_xml))
            
            return True
            

        Series_to_plot  = ['KWH']

        chart1          = chart('%s/viewer/Date-Time-Bar.xml'%abs_path)

        chart1.xml_process(data=[consumo_array], Series_to_plot=Series_to_plot, scale=scale, \
                       Titles=labels, formatos=formatos,integral=[0,0,0],timeformat=timeformat)
        #print '%s%s'%(self.path_to_save,file_name_xml)
        chart1.save_file('%s%s'%(self.path_to_save,file_name_xml))
        
        return True
Exemple #22
0
    def plotprofile_kw(self,timeformat,date, Elec_Tools_handler):
        
        import calendar
        power_array   =   []
        
        if timeformat == 'week':
            t0  =   date.replace(day=date.day,hour=0,minute=0,second=0,microsecond=0)-datetime.timedelta(days=date.weekday()+7)
            t1  =   date.replace(day=date.day,hour=0,minute=0,second=0,microsecond=0)-datetime.timedelta(days=date.weekday())
            t2  =   date.replace(day=date.day,hour=23,minute=59,second=59,microsecond=0)+datetime.timedelta(days=6)-datetime.timedelta(days=date.weekday())
        elif timeformat == 'month' and date.month==1:
            t0  =   date.replace(year=date.year-1,month=12,day=1,hour=0,minute=0,second=0,microsecond=0)-datetime.timedelta(days=date.replace(year=date.year-1,month=12,day=1,hour=0,minute=0,second=0,microsecond=0).weekday())
            t1  =   date.replace(day=1,hour=0,minute=0,second=0,microsecond=0)
            t2  =   date.replace(year=date.year,month=1,day=calendar.mdays[1],hour=23,minute=59,second=59,microsecond=0)+datetime.timedelta(days=6-date.replace(year=date.year-1,month=12,day=1,hour=0,minute=0,second=0,microsecond=0).weekday())
        elif timeformat == 'month':
            t0  =   date.replace(month=date.month-1,day=1,hour=0,minute=0,second=0,microsecond=0)-datetime.timedelta(days=date.replace(month=date.month-1,day=1,hour=0,minute=0,second=0,microsecond=0).weekday())
            t1  =   date.replace(day=1,hour=0,minute=0,second=0,microsecond=0)
            t2  =   date.replace(day=calendar.mdays[date.month],hour=23,minute=59,second=59,microsecond=0)+datetime.timedelta(days=6-date.replace(day=calendar.mdays[date.month],hour=23,minute=59,second=59,microsecond=0).weekday())
        elif timeformat == 'year' and date.month==1:
            t0  =   date.replace(year=date.year-1,month=1,day=1,hour=0,minute=0,second=0,microsecond=0)
            t1  =   date.replace(month=1,day=1,hour=0,minute=0,second=0,microsecond=0)
            t2  =   date.replace(month=12,day=calendar.mdays[12],hour=23,minute=59,second=59,microsecond=0)+datetime.timedelta(days=6-date.replace(year=date.year-1,month=12,day=1,hour=0,minute=0,second=0,microsecond=0).weekday())
        elif timeformat == 'year':
            t0  =   date.replace(month=date.month-1,day=1,hour=0,minute=0,second=0,microsecond=0)-datetime.timedelta(days=date.replace(year=date.year-1,month=12,day=1,hour=0,minute=0,second=0,microsecond=0).weekday())
            t1  =   date.replace(day=1,hour=0,minute=0,second=0,microsecond=0)
            t2  =   date.replace(day=calendar.mdays[date.month],hour=23,minute=59,second=59,microsecond=0)+datetime.timedelta(days=6-date.replace(year=date.year-1,month=12,day=1,hour=0,minute=0,second=0,microsecond=0).weekday())
        elif timeformat == 'report_power_month':
            t0  =   date.replace(day=1,hour=0,minute=0,second=0,microsecond=0)
            t1  =   t0
            t2  =   date.replace(day=calendar.mdays[date.month],hour=0,minute=0,second=0,microsecond=0)
        
        period = {'week':{'t0':t0,\
                          't1':t1,\
                          't2':t2,\
                          'date':'%s - %s'%((t1).strftime("%d/%m"),t2.strftime("%d/%m"))},\
                  'month':{'t0':t0,\
                           't1':t1,\
                          't2':t2,\
                          'date':'%s'%t2.strftime("%m/%Y")},\
                  'year':{'t0':date.replace(year=date.year-1,month=1,day=1,hour=0,minute=0,second=0,microsecond=0),\
                          't1':date.replace(month=1,day=1,hour=0,minute=0,second=0,microsecond=0),\
                          't2':date.replace(month=12,day=calendar.mdays[12],hour=23,minute=59,second=59,microsecond=0),\
                          'date':'%s'%t2.strftime("%Y")},\
                  'report_power_month':{'t0':t0,\
                                         't2':t2}
                } 
        
        
        if timeformat   == 'report_power_month':
            analisis_detailed   =   []
            power_array_PPP     =   []
            power_array_PP      =   []
            maximos             =   {'PPP':{'Value':0},'PP':{'Value':0}}
            ave_sum_PPP         =   0
            ave_sum_PP          =   0
            
            for r in range(calendar.mdays[date.month]):
                date_r      =   period['report_power_month']['t0'] + datetime.timedelta(days=r)
                
                analisis_detailed.append(Elec_Tools_handler.demand_analysis(date=date_r,type='day'))
                
                power_array_PPP.append({'PPP':analisis_detailed[r]['PPP']['Value'],\
                                    'datetimestamp':date_r,\
                                    'Style':'current'})
                power_array_PP.append({'PP':analisis_detailed[r]['PP']['Value'],\
                                    'datetimestamp':date_r,\
                                    'Style':'current'})
                
                if analisis_detailed[r]['PPP']['Value'] > maximos['PPP']['Value']:
                    maximos['PPP']=analisis_detailed[r]['PPP']
                if analisis_detailed[r]['PP']['Value'] > maximos['PP']['Value']:
                    maximos['PP']=analisis_detailed[r]['PP']    
                
                ave_sum_PPP=ave_sum_PPP+analisis_detailed[r]['PPP']['ave']
                ave_sum_PP=ave_sum_PPP+analisis_detailed[r]['PP']['ave']
                
            
            maximos['PPP']['ave']=pretty_print(float(ave_sum_PPP)/calendar.mdays[date.month],scale=1000000000,label=['KW','MW'])
            maximos['PP']['ave']=pretty_print(float(ave_sum_PP)/calendar.mdays[date.month],scale=1000000000,label=['KW','MW'])
            
            
            scale           = { 'major_interval':1,
                           'major_interval_unit': 'Day', \
                           'minor_interval':1, \
                           'minor_interval_unit': 'Hour',\
                           'xmin': '%s' % period['report_power_month']['t0'], \
                           'xmax': '%s' % period['report_power_month']['t2'], \
                           'ymin':0,\
                           'ymax':40000,\
                           'autoscale':'on'}

            labels          = ['Perfiles de demandas maximas del mes','KW','KW','m3/hr','m3/hr']
             
            formatos        = {'xinputformat':'%yyyy-%MM-%dd %HH:%mm:%ss',\
                           'xlabelformat':'{%Value}{dateTimeFormat: %dd}',\
                           'tooltipformat':'Valor: {%YValue}{numDecimals:0}Kwh',\
                           'ylabelformat':'{%Value}{numDecimals:0}',\
                           'y2labelformat':'{%Value}{numDecimals:0}',\
                           'y3labelformat':'{%Value}{numDecimals:0}'}

        Series_to_plot  = ['PPP','PP']

        chart1          = chart('%s/viewer/Date-Time-Line-demandas.xml'%abs_path)

        chart1.xml_process(data=[power_array_PPP,power_array_PP], Series_to_plot=Series_to_plot, scale=scale, \
                           Titles=labels, formatos=formatos,integral=[0,0,0],timeformat=timeformat)
        chart1.save_file('%sdemandas_mensual.xml'%(self.path_to_save))
        
    
        return maximos
Exemple #23
0
    def plotyearenergy(self):
        
        date_current        =   self.dates
        date_previous       =   date_current.replace(year=date_current.year - 1,month=1,day=1)

        data_to_process     =   Measurements.objects.\
                                    filter(user = self.user,\
                                    sensor = Sensors.objects.get(pk=self.sensor_id),\
                                    datetimestamp__gte = date_previous).\
                                    filter(datetimestamp__lte = date_current+datetime.timedelta(days=1)).\
                                    order_by('datetimestamp').\
                                    values('Pactiva','datetimestamp')

        data_size           = len(data_to_process)

        energy_per_month    = []
        pointer             = 0

        date_previous       = date_current.replace(year=date_current.year - 1,month=1,day=1,hour=0,minute=0,second=0,microsecond=0)


        for month in range(24):
            #Calculation of energy consumption each hour
            month_acum      = 0

            if month >= 11 and month <23:
                segmento    = date_previous.replace(year=date_previous.year+1,month=month-10,hour=0,minute=0,second=0,microsecond=0)
            elif month == 23:
                segmento    = date_current.replace(month=12,day=1,hour=0,minute=0,second=0,microsecond=0)
            else:
                segmento    = date_previous.replace(month=month+2,hour=0,minute=0,second=0,microsecond=0)

            while pointer < data_size-1:

                x_delta_time_num    = date2num(data_to_process[pointer+1]['datetimestamp'])-date2num(data_to_process[pointer]['datetimestamp'])
                power_x             = data_to_process[pointer]['Pactiva']
                month_acum          = month_acum + power_x * x_delta_time_num * 24


                if data_to_process[pointer + 1]['datetimestamp'].replace(tzinfo=None) >= segmento:
                    pointer = pointer + 1
                    break
                else:
                    pointer = pointer + 1

            if month < 11:
                #print segmento.month-1,month
                energy_per_month.append({'datetimestamp':segmento.replace(month=segmento.month-1),\
                                        'Pactiva':int(month_acum),\
                                        'Style':'previous'})
            elif month ==11:
                #print 12,month
                energy_per_month.append({'datetimestamp':segmento.replace(month=12),\
                                        'Pactiva':int(month_acum),\
                                        'Style':'previous'})
            elif month < 23:
                #print segmento.month-1,month
                energy_per_month.append({'datetimestamp':segmento.replace(month=segmento.month-1),\
                                        'Pactiva':int(month_acum),\
                                        'Style':'current'})
            else:
                #print 12,month
                energy_per_month.append({'datetimestamp':segmento.replace(month=12),\
                                        'Pactiva':int(month_acum),\
                                        'Style':'current'})
        data_to_plot    = [energy_per_month]

       
        chart1          = chart('%s/viewer/Date-Time-Bar.xml'%abs_path)

        chart1.xml_process(data_to_plot, scale, ['Energia consumida por mes','Kwh','Hora','m3/hr','m3/hr'], formatos,[0,0,0],timeformat='year')

        chart1.save_file('%s/media/charts/grafico_1D.xml'%abs_path)
Exemple #24
0
    def plotdayprofile(self,signal=None,date=None):
        
        #SELECCION DE DATOS
        t0  =   date.replace(hour=0,minute=0,second=0) - datetime.timedelta(days=1)
        t1  =   date.replace(hour=0,minute=0,second=0)
        t2  =   date.replace(hour=23,minute=59,second=59)
        
        data_to_process     =   list(Measurements.objects.filter(user= self.user,sensor=Sensors.objects.get(pk=self.sensor_id),\
                                                            datetimestamp__range= (t0,t2)).extra(select=sql_extra_pairs[signal]['sql']).\
                                                            order_by('datetimestamp').values('datetimestamp',sql_extra_pairs[signal]['extra']))
        
        serie    = []
        
        #print data_to_process
        data_size=len(data_to_process)
        
        #calculo de potencia
        if signal=='A_KW' or signal=='B_KW' or signal=='C_KW' or signal=='Total_KW':
            
            data_to_process[0][signal]  =   0
            #print data_to_process[0][signal]
                    
            for r in range(data_size-1):
                delta_time  =   (date2num(data_to_process[r+1]['datetimestamp'])-date2num(data_to_process[r]['datetimestamp']))*24
                Power_in_r  =   float(data_to_process[r+1][sql_extra_pairs[signal]['extra']])/(delta_time)   
                
                data_to_process[r+1][signal]    =   Power_in_r 
            
        
        #CONSTRUCCION DE DICT PARA PLOTEO
        for pointer in range(data_size):
            
            if data_to_process[pointer]['datetimestamp'].replace(tzinfo=None) < t1:
                serie.append({'datetimestamp':data_to_process[pointer]['datetimestamp'],\
                               signal:data_to_process[pointer][sql_extra_pairs[signal]['plot']]*ganancias_dict[signal]['gain'],\
                               'Style':'previous'})
            else:
                serie.append({'datetimestamp':data_to_process[pointer]['datetimestamp'],\
                                    signal:data_to_process[pointer][sql_extra_pairs[signal]['plot']]*ganancias_dict[signal]['gain'],\
                                    'Style':'current'})
        data_to_plot = [serie] #datos parseados

        #FORMATOS DE ANYCHART
        scale           = { 'major_interval':6,\
                          'major_interval_unit': 'Hour', \
                          'minor_interval':30, \
                          'minor_interval_unit': 'Minute',\
                          'xmin': '%s' % t0, \
                          'xmax': '%s' % t2, \
                          'ymin':0,\
                          'ymax':40000,\
                          'autoscale':'on'}

        formatos        = {'xinputformat':'%yyyy-%MM-%dd %HH:%mm:%ss',\
                           'xlabelformat':'{%Value}{dateTimeFormat:%HH:%mm \n%dd-%MM}',\
                           'tooltipformat':'Valor: {%YValue}{numDecimals:2} \n{%XValue}{dateTimeFormat:%HH:%mm \n%dd-%MM-%yyyy}',\
                           'ylabelformat':'{%Value}{numDecimals:0}',\
                           'y2labelformat':'{%Value}{numDecimals:0}',\
                           'y3labelformat':'{%Value}{numDecimals:0}'}
        
        Series_to_plot  = [signal] #key de la serie a plotear
        labels          = [ganancias_dict[signal]['chartTitle'],ganancias_dict[signal]['chartLabel'],'Hora','m3/hr','m3/hr']
        chart1          = chart('%s/viewer/Date-Time-Line-3.xml'%abs_path)

        chart1.xml_process(data=data_to_plot, Series_to_plot=Series_to_plot, scale=scale, \
                           Titles=labels, formatos=formatos,integral=[0,0,0],timeformat='daypower')
        chart1.save_file('%sgrafico_1D.xml'%self.path_to_save)
Exemple #25
0
    def plotyearenergy(self):

        date_current = self.dates
        date_previous = date_current.replace(year=date_current.year - 1,
                                             month=1,
                                             day=1)

        data_to_process     =   Measurements.objects.\
                                    filter(user = self.user,\
                                    sensor = Sensors.objects.get(pk=self.sensor_id),\
                                    datetimestamp__gte = date_previous).\
                                    filter(datetimestamp__lte = date_current+datetime.timedelta(days=1)).\
                                    order_by('datetimestamp').\
                                    values('Pactiva','datetimestamp')

        data_size = len(data_to_process)

        energy_per_month = []
        pointer = 0

        date_previous = date_current.replace(year=date_current.year - 1,
                                             month=1,
                                             day=1,
                                             hour=0,
                                             minute=0,
                                             second=0,
                                             microsecond=0)

        for month in range(24):
            #Calculation of energy consumption each hour
            month_acum = 0

            if month >= 11 and month < 23:
                segmento = date_previous.replace(year=date_previous.year + 1,
                                                 month=month - 10,
                                                 hour=0,
                                                 minute=0,
                                                 second=0,
                                                 microsecond=0)
            elif month == 23:
                segmento = date_current.replace(month=12,
                                                day=1,
                                                hour=0,
                                                minute=0,
                                                second=0,
                                                microsecond=0)
            else:
                segmento = date_previous.replace(month=month + 2,
                                                 hour=0,
                                                 minute=0,
                                                 second=0,
                                                 microsecond=0)

            while pointer < data_size - 1:

                x_delta_time_num = date2num(
                    data_to_process[pointer + 1]['datetimestamp']) - date2num(
                        data_to_process[pointer]['datetimestamp'])
                power_x = data_to_process[pointer]['Pactiva']
                month_acum = month_acum + power_x * x_delta_time_num * 24

                if data_to_process[pointer + 1]['datetimestamp'].replace(
                        tzinfo=None) >= segmento:
                    pointer = pointer + 1
                    break
                else:
                    pointer = pointer + 1

            if month < 11:
                #print segmento.month-1,month
                energy_per_month.append({'datetimestamp':segmento.replace(month=segmento.month-1),\
                                        'Pactiva':int(month_acum),\
                                        'Style':'previous'})
            elif month == 11:
                #print 12,month
                energy_per_month.append({'datetimestamp':segmento.replace(month=12),\
                                        'Pactiva':int(month_acum),\
                                        'Style':'previous'})
            elif month < 23:
                #print segmento.month-1,month
                energy_per_month.append({'datetimestamp':segmento.replace(month=segmento.month-1),\
                                        'Pactiva':int(month_acum),\
                                        'Style':'current'})
            else:
                #print 12,month
                energy_per_month.append({'datetimestamp':segmento.replace(month=12),\
                                        'Pactiva':int(month_acum),\
                                        'Style':'current'})
        data_to_plot = [energy_per_month]

        chart1 = chart('%s/viewer/Date-Time-Bar.xml' % abs_path)

        chart1.xml_process(
            data_to_plot,
            scale,
            ['Energia consumida por mes', 'Kwh', 'Hora', 'm3/hr', 'm3/hr'],
            formatos, [0, 0, 0],
            timeformat='year')

        chart1.save_file('%s/media/charts/grafico_1D.xml' % abs_path)
Exemple #26
0
 def plotenergydistribution(self,Data):
     chart1          = chart('%s/viewer/cake-energy-distribution.xml'%abs_path)
     chart1.pie_build_xml(Data)
     
     chart1.save_file('%s%s'%(self.path_to_save,'cake-energy-distribution.xml'))
Exemple #27
0
    def initUI(self):
        mainWidget = QtGui.QWidget()
        hbox = QtGui.QHBoxLayout(mainWidget)

        self.rightbottom = QtGui.QWidget(mainWidget)
        #self.rightbottom.setFixedHeight(400)

        grid = QtGui.QGridLayout()
        self.rightbottom.setLayout(grid)

        btnStretch = QtGui.QPushButton('Stretch Histogram',self.rightbottom)
        btnStretch.clicked.connect(self.stretchHisto)
        grid.addWidget(btnStretch, 0,0)

        btnShrink = QtGui.QPushButton('Shrink Histogram', self.rightbottom)
        btnShrink.clicked.connect(self.shrinkHisto)
        grid.addWidget(btnShrink, 1,0)

        btnSlidesLeft = QtGui.QPushButton('Slides Left Histogram', self.rightbottom)
        btnSlidesLeft.clicked.connect(self.slidesLeftHisto)
        grid.addWidget(btnSlidesLeft, 2,0)

        btnSlidesRight = QtGui.QPushButton('Slides Right Histogram', self.rightbottom)
        btnSlidesRight.clicked.connect(self.slidesRightHisto)
        grid.addWidget(btnSlidesRight, 3,0)

        btnHistogramEq = QtGui.QPushButton('Histogram Equalization', self.rightbottom)
        btnHistogramEq.clicked.connect(self.histogramEqualization)
        grid.addWidget(btnHistogramEq, 4,0)
        
        btnNegative = QtGui.QPushButton('Negative', self.rightbottom)
        btnNegative.clicked.connect(self.negative)
        grid.addWidget(btnNegative, 5,0)

        btnMeanFilter = QtGui.QPushButton('Local Operations(mean)', self.rightbottom)
        btnMeanFilter.clicked.connect(self.meanFilter)
        grid.addWidget(btnMeanFilter, 6,0)

        btnMedianFilter = QtGui.QPushButton('Local Operations(median)', self.rightbottom)
        btnMedianFilter.clicked.connect(self.medianFilter)
        grid.addWidget(btnMedianFilter, 7,0)

        btnEdgeDetection = QtGui.QPushButton('Edge Detection', self.rightbottom)
        btnEdgeDetection.clicked.connect(self.edgeDetection)
        grid.addWidget(btnEdgeDetection, 8,0)

        #btnRest = QtGui.QPushButton('Rest', self.rightbottom)
        #grid.addWidget(btnRest, 9,0)

        lblSlidesLeft = QtGui.QLabel('By:')
        grid.addWidget(lblSlidesLeft, 2,1)

        self.slidesLeftEdit = QtGui.QLineEdit()
        grid.addWidget(self.slidesLeftEdit, 2,2)

        lblSlidesRight = QtGui.QLabel('By:')
        grid.addWidget(lblSlidesRight, 3,1)

        self.slidesRightEdit = QtGui.QLineEdit()
        grid.addWidget(self.slidesRightEdit, 3,2)

        lblMaxR = QtGui.QLabel('Max:')
        grid.addWidget(lblMaxR, 1,1)

        self.maxREdit = QtGui.QLineEdit()
        grid.addWidget(self.maxREdit, 1,2)

        lblMinR = QtGui.QLabel('Min:')
        grid.addWidget(lblMinR, 1,3)

        self.minREdit = QtGui.QLineEdit()
        grid.addWidget(self.minREdit, 1,4)

        #hide it, its empty
        self.rightbottom.hide()

        self.imageWidget = imageWidget()
        #self.imgPreProc.setFixedSize(800,650)

        self.histoChart = chart()
        #self.histoChart.setFixedHeight(180)

        splitter1 = QtGui.QSplitter(QtCore.Qt.Vertical)
        splitter1.addWidget(self.histoChart)
        splitter1.addWidget(self.rightbottom)

        splitter2 = QtGui.QSplitter(QtCore.Qt.Horizontal)
        splitter2.addWidget(self.imageWidget)
        splitter2.addWidget(splitter1)

        hbox.addWidget(splitter2)
        mainWidget.setLayout(hbox)
        """
        #new stuff
        splitter1 = QtGui.QSplitter(QtCore.Qt.Vertical)# down right
        splitter1.addWidget(self.rightbottom) #controls
        splitter1.addWidget(self.histoChart) #right chart

        splitter2 = QtGui.QSplitter(QtCore.Qt.Vertical) # down
        splitter2.addWidget(self.histoChart) # left chart
        splitter2.addWidget(splitter1)

        splitter3 = QtGui.QSplitter(QtCore.Qt.Vertical) # up
        splitter3.addWidget(self.imgPreProc) #left image
        splitter3.addWidget(self.imgPreProc) #right image

        splitter4 = QtGui.QSplitter(QtCore.Qt.Horizontal)
        splitter4.addWidget(splitter3)
        splitter4.addWidget(splitter2)

        hbox.addWidget(splitter4)
        mainWidget.setLayout(hbox)
        #end new stuff
        """

        self.setCentralWidget(mainWidget)

        #a try of making a status bar
        statusBar = QtGui.QStatusBar()
        statusBar.setFixedHeight(18)
        self.setStatusBar(statusBar)
        self.statusBar().showMessage(self.tr("Ready"))

        self.progressBar = QtGui.QProgressBar(self.statusBar())
        self.progressBar.setMaximum(0)
        self.progressBar.setMinimum(100)
        self.statusBar().addPermanentWidget(self.progressBar)
        

        self.setupMenu()

        #self.setGeometry(300, 300, 1200, 700)
        self.showMaximized()
        self.setWindowTitle('Image Processing')
        self.setWindowIcon(QtGui.QIcon('IP.gif'))
        self.show()
Exemple #28
0
    def plotenergydistribution(self, Data):
        chart1 = chart('%s/viewer/cake-energy-distribution.xml' % abs_path)
        chart1.pie_build_xml(Data)

        chart1.save_file('%s%s' %
                         (self.path_to_save, 'cake-energy-distribution.xml'))