def day_profile(self, dini, dfi, real_consumption_hourly): assert type( real_consumption_hourly ) == list, "Real hourly consumption for this day must be a list" date_start = TIMEZONE.localize(dini) date_end = TIMEZONE.localize(dini) estimated = Profile(date_start, date_end, []).estimate(t, {'P1': 5})
def get_range(self, start, end): assert isinstance(start, date) assert isinstance(end, date) start = TIMEZONE.localize(datetime(start.year, start.month, start.day, 1), is_dst=True) # Sum one day to get the hour 00:00 of the next day end += timedelta(days=1) end = TIMEZONE.localize(datetime(end.year, end.month, end.day), is_dst=True) + timedelta(seconds=1) pos = bisect.bisect_left(self.coefs, Coefficent(start, {})) self._check_pos(pos) end_pos = bisect.bisect_right(self.coefs, Coefficent(end, {})) return self.coefs[pos:end_pos]
def get_range(self, start, end): assert isinstance(start, date) assert isinstance(end, date) start = TIMEZONE.localize(datetime( start.year, start.month, start.day, 1), is_dst=True ) # Sum one day to get the hour 00:00 of the next day end += timedelta(days=1) end = TIMEZONE.localize(datetime( end.year, end.month, end.day), is_dst=True ) + timedelta(seconds=1) pos = bisect.bisect_left(self.coefs, Coefficent(start, {})) self._check_pos(pos) end_pos = bisect.bisect_right(self.coefs, Coefficent(end, {})) return self.coefs[pos:end_pos]
def process_consumptions(self): """ Process all FacturaATR of the imported F1 For each period create the related profile and estimate Create the related Consumption objecte and save it (if more significant) to DB """ invoices = self.invoices # Get all FacturaATR invoices for factura_atr in invoices['FacturaATR']: #self.print_invoice_summary(factura_atr) periods, consumption_total = factura_atr.get_info_activa() tariff_code = factura_atr.codi_tarifa tariff_name = defs.INFO_TARIFA[tariff_code]['name'] tariff = get_tariff_by_code(tariff_name)() # Profile and estimate Invoice range for each period for period in periods: assert isinstance(period.data_inici, str) assert isinstance(period.data_final, str) start_hour = TIMEZONE.localize( self.convert_string_to_datetime(period.data_inici)) end_hour = TIMEZONE.localize( self.convert_string_to_datetime(period.data_final)) measures = [] profile = Profile(start_hour, end_hour, measures) estimation = profile.estimate( tariff, {str(period.name): int(period.quantitat)}) logger.debug(estimation) # For each measure of the profile create a Consumption for measure in estimation.measures: logger.debug(" [F1] Processing {} {} {}".format( factura_atr.cups, measure.date, measure.measure)) consumption_from_measure = Consumption( cups=factura_atr.cups, hour=measure.date, real=measure.measure, origin=self.type) # Save (Upsert) consumtion following strategy "importance of data" self.save_consumption_if_needed(consumption_from_measure)
def get_range(self, start, end): assert isinstance(start, date) assert isinstance(end, date) start = TIMEZONE.localize(datetime( start.year, start.month, start.day, 1), is_dst=True ) # Sum one day to get the hour 00:00 of the next day end += timedelta(days=1) end = TIMEZONE.localize(datetime( end.year, end.month, end.day), is_dst=True ) + timedelta(seconds=1) pos = bisect.bisect_left(self.coefs, (start, {})) if pos == len(self.coefs): raise ValueError('start date not found in coefficients') end_pos = bisect.bisect_right(self.coefs, (end, {})) return self.coefs[pos:end_pos]
def get_station(dt): assert isinstance(dt, datetime) if not dt.tzinfo: dt = TIMEZONE.localize(dt) if TIMEZONE.normalize(dt).dst(): return 'summer' else: return 'winter'
def get(self, dt): assert isinstance(dt, datetime) if dt.dst() is None: dt = TIMEZONE.localize(dt) dt = TIMEZONE.normalize(dt) pos = bisect.bisect_left(self.coefs, Coefficent(dt, {})) self._check_pos(pos) return self.coefs[pos]
def get(cls, year, month): try: import ssl try: _create_unverified_https_context = ssl._create_unverified_context except AttributeError: pass else: ssl._create_default_https_context = _create_unverified_https_context except ImportError: pass try: cls.down_lock.acquire() import csv import httplib key = '%(year)s%(month)02i' % locals() conn = None if key in cls._CACHE: logger.debug('Using CACHE for REEProfile {0}'.format(key)) return cls._CACHE[key] perff_file = 'PERFF_%(key)s.gz' % locals() conn = httplib.HTTPSConnection(cls.HOST) conn.request('GET', '%s/%s' % (cls.PATH, perff_file)) logger.debug('Downloading REEProfile from {0}/{1}'.format( cls.PATH, perff_file)) r = conn.getresponse() if r.msg.type == 'application/x-gzip': import gzip c = StringIO(r.read()) m = StringIO(gzip.GzipFile(fileobj=c).read()) c.close() reader = csv.reader(m, delimiter=';') header = True cofs = [] coeffs_list = get_tariff_coeffs_list(year, month) for vals in reader: if header: header = False continue if int(vals[3]) == 1: n_hour = 1 dt = datetime(int(vals[0]), int(vals[1]), int(vals[2])) day = TIMEZONE.localize(dt, is_dst=bool(not int(vals[4]))) day += timedelta(hours=n_hour) n_hour += 1 cofs.append( Coefficent( TIMEZONE.normalize(day), dict((k, float(vals[i])) for i, k in enumerate(coeffs_list, 5)))) cls._CACHE[key] = cofs return cofs else: raise Exception('Profiles from REE not found') finally: if conn is not None: conn.close() cls.down_lock.release()
def process_consumptions(self): """ Process all Lectures of the imported Q1 For each period create the related profile and estimate Create the related Consumption object and save it (if more significant) to DB """ lectures = self.lectures # Get all FacturaATR lectures for lectura in lectures: # todo fetch Tariff? ## tariff_code = factura_atr.codi_tarifa ## tariff_name = defs.INFO_TARIFA[tariff_code]['name'] ## tariff = get_tariff_by_code(tariff_name)() tariff = T20A() start_hour = TIMEZONE.localize(self.convert_string_to_datetime( lectura['data_inici'])) end_hour = TIMEZONE.localize(self.convert_string_to_datetime( lectura['data_final'])) measures = [] profile = Profile(start_hour, end_hour, measures) estimation = profile.estimate( tariff, {str(lectura['periode']): int(lectura['consum'])}) logger.debug(estimation) # For each measure of the profile create a Consumption for measure in estimation.measures: logger.debug(" [Q1] Processing {} {} {}".format(lectura[ 'cups'], measure.date, measure.measure)) consumption_from_measure = Consumption( cups=lectura['cups'], hour=measure.date, real=measure.measure, origin=self.type, time_disc=lectura['codiDH']) # Save (Upsert) consumtion following strategy "importance of data" self.save_consumption_if_needed(consumption_from_measure)
def get_period_by_timestamp(self, timestamp): """ Gets the number of energy period :param timestamp: datetime in format 'YYYY-MM-DD HH' :return: period number """ day, hours = timestamp.split(' ') dt_tz = TIMEZONE.normalize(TIMEZONE.localize(datetime.strptime(day, '%Y-%m-%d')) + timedelta(hours=int(hours))) # "get_period_by_date" expects a local timestamp without timezone # decreases 1 minute because is final datetime open interval (not included) dt = dt_tz.replace(tzinfo=None) - timedelta(minutes=1) return self.get_period_by_date(dt).code
def get(cls, year, month): try: cls.down_lock.acquire() import csv import httplib key = '%(year)s%(month)02i' % locals() conn = None if key in cls._CACHE: logger.debug('Using CACHE for REEProfile {0}'.format(key)) return cls._CACHE[key] perff_file = 'PERFF_%(key)s.gz' % locals() conn = httplib.HTTPConnection(cls.HOST) conn.request('GET', '%s/%s' % (cls.PATH, perff_file)) logger.debug('Downloading REEProfile from {0}/{1}'.format( cls.PATH, perff_file )) r = conn.getresponse() if r.msg.type == 'application/x-gzip': import gzip c = StringIO(r.read()) m = StringIO(gzip.GzipFile(fileobj=c).read()) c.close() reader = csv.reader(m, delimiter=';') header = True cofs = [] for vals in reader: if header: header = False continue if int(vals[3]) == 1: n_hour = 1 dt = datetime( int(vals[0]), int(vals[1]), int(vals[2]) ) day = TIMEZONE.localize(dt, is_dst=bool(not int(vals[4]))) day += timedelta(hours=n_hour) n_hour += 1 cofs.append(Coefficent( TIMEZONE.normalize(day), dict( (k, float(vals[i])) for i, k in enumerate('ABCD', 5) )) ) cls._CACHE[key] = cofs return cofs else: raise Exception('Profiles from REE not found') finally: if conn is not None: conn.close() cls.down_lock.release()
def parse_line(self, line): """ Create the Consumption object from a P5D line and save it (if more significant) to DB """ data = line['cchval'].data cups = data['name'] consumption = data['ai'] #ao = data['ao'] hour = TIMEZONE.localize(data['datetime']) logger.debug(" [P5D] Processing {} {} {}".format( cups, hour, consumption)) consumption_from_line = Consumption(cups=cups, hour=hour, real=consumption, origin=self.type) # Save (Upsert) consumption following strategy "importance of data" self.save_consumption_if_needed(consumption_from_line)
def get(cls, m, header): import csv reader = csv.reader(m, delimiter=';') cofs = [] n_hour = 0 for vals in reader: if header: header = False continue if int(vals[3]) == 1: n_hour = 1 dt = datetime( int(vals[0]), int(vals[1]), int(vals[2]) ) day = TIMEZONE.localize(dt, is_dst=bool(not int(vals[4]))) day += timedelta(hours=n_hour) n_hour += 1 cofs.append( (TIMEZONE.normalize(day), dict( (k, float(vals[i])) for i, k in enumerate('ABCD', 5) )) ) return cofs
def get(self, year, month): key = '%(year)s%(month)02i' % locals() if key in self._CACHE: logger.debug('Using CACHE for REEProfile {0}'.format(key)) return self._CACHE[key] with open(self.path, 'r') as m: reader = csv.reader(m, delimiter=';') header = 2 cofs = [] for vals in reader: if header: header -= 1 continue if int(vals[0]) != month: continue dt = datetime(year, int(vals[0]), int(vals[1])) day = TIMEZONE.localize(dt) + timedelta(hours=int(vals[2])) cofs.append( Coefficent( TIMEZONE.normalize(day), dict((k, float(vals[i])) for i, k in enumerate('ABCD', 3)))) self._CACHE[key] = cofs return cofs
from enerdata.datetime import datetime from enerdata.datetime.station import get_station from enerdata.datetime.solar_hour import convert_to_solar_hour from enerdata.datetime.timezone import TIMEZONE from dateutil.relativedelta import relativedelta from expects import expect, equal, raise_error DIFFERENCE_HOURS = {'summer': 2, 'winter': 1} with description("The solar hour"): with context("in Summer"): with it("is the civil time plus 2"): dt = TIMEZONE.localize(datetime(2019, 4, 1, 1)) final_dt = dt + relativedelta(months=3) hours = DIFFERENCE_HOURS['summer'] while dt < final_dt: dt = dt + relativedelta(hours=1) solar_hour = convert_to_solar_hour(dt) civil_hour_to_expect = dt - relativedelta(hours=hours) assert civil_hour_to_expect.hour == solar_hour.hour with it("is the civil time plus 1"): dt = TIMEZONE.localize(datetime(2019, 11, 1, 1)) final_dt = dt + relativedelta(months=3) hours = DIFFERENCE_HOURS['winter'] while dt < final_dt: dt = dt + relativedelta(hours=1) solar_hour = convert_to_solar_hour(dt) civil_hour_to_expect = dt - relativedelta(hours=hours) assert civil_hour_to_expect.hour == solar_hour.hour
from enerdata.datetime import datetime from enerdata.datetime.timezone import TIMEZONE from enerdata.datetime.station import * with description('The station module'): with it('has to return the station by date'): assert get_station(datetime(2014, 1, 1)) == 'winter' assert get_station(datetime(2014, 4, 1)) == 'summer' assert get_station(datetime(2014, 10, 26, 2)) == 'winter' assert get_station(datetime(2014, 3, 30, 2)) == 'summer' assert get_station(TIMEZONE.localize(datetime(2014, 10, 26, 2), is_dst=True)) == 'summer'