continued work on project

Author: Eowyn42

students/eowyn/windrevenue/windrevenue/UI.py

@@ -10,14 +10,24 @@
 
 class UI():
 
-    def __init__(self):
+    def __init__(self, met=met, pct=pct, pricing=pricing):
         """
         Instantiate classes to store state related to
         different data and funcionality.
         """
-        self.met = met()
-        self.pct = pct()
-        self.pricing = pricing()
+        if met is not None:
+            self.met = met
+        else:
+            self.met = met()
+        if pct is not None:
+            self.pct = pct
+        else:
+            self.pct = pct()
+        if pricing is not None:
+            self.pricing = pricing
+        else:
+            self.pricing = pricing()
+
         self.peak = peak()
         self.rev = rev()
         self.ad = ad()

students/eowyn/windrevenue/windrevenue/align_data.py

@@ -18,19 +18,29 @@
 """
 
 import pandas as pd
-import numpy as np
+#import pdb
+
 
 class AlignData():
+
+    @staticmethod
+    def get_typical_year():
+        # Construct a dummy TimeStamp index for the typical year
+        return pd.date_range('2015-01-01', periods=8760, freq='H')
+
     def __init__(self, price_data=None, met_data=None):
         self.pricing = price_data
         self.met = met_data
 
     def resample_timeseries(self, timestep='60min'):
         """
         Resample met, generation, and power pricing data to hourly
+        TO DO: Handle missing vals introduced by re-indexing better
         """
-        self.power_hour = self.pricing.get_pricing_field().resample(timestep).mean()
-        self.met_hour = self.met.get_wind_and_generation().resample(timestep).mean()
+        repwr = self.pricing.get_pricing_field().resample(timestep).mean()
+        self.power_hour = repwr.bfill()
+        remet = self.met.get_wind_and_generation().resample(timestep).mean()
+        self.met_hour = remet.bfill()
 
     def determine_overlap(self):
         # Check if there of overlap between generation and pricing data
@@ -82,17 +92,19 @@ def calculate_typical_year(self):
         At this point, the datetime axis is no longer available. 
         We will deal with leap-years then re-create the TimeStamp index.
         """
+        #pdb.set_trace()
         self.met_yr = self.met_hour.groupby([self.met_hour.index.month,
                                            self.met_hour.index.day,
                                            self.met_hour.index.hour]).mean()
         self.pwr_yr = self.power_hour.groupby([self.power_hour.index.month,
                                                self.power_hour.index.day,
                                              self.power_hour.index.hour]).mean()
-        self.met_yr = self.met_yr.remove_leap_day()
-        self.pwr_yr = self.pwr_yr.remove_leap_day()
+        self.remove_leap_day()
         typical_year = self.get_typical_year()
-        self.met_yr.index, self.met_yr.index.names = typical_year, ["TimeStamp"]
-        self.pwr_yr.index, self.pwr_yr.index.names = typical_year, ["TimeStamp"]
+        self.met_yr.index = typical_year
+        self.met_yr.index.names =  ["TimeStamp"]
+        self.pwr_yr.index = typical_year
+        self.pwr_yr.index.names = ["TimeStamp"]
 
 
     def remove_leap_day(self):
@@ -103,28 +115,26 @@ def remove_leap_day(self):
         Drop all Feb 29 rows:
         temp2 = temp.drop(temp.index[1416:1440], axis = 0)
         """
-        if len(self.met_hour.index) == 8784:
+        if len(self.met_yr.index) == 8784:
             print("removing leap day from met year")
-            self.met_yr = self.met_hour.drop(self.met_hour.index[1416:1440], axis=0)
-        if len(self.power_hour.index) == 8784:
+            self.met_yr = self.met_yr.drop(self.met_yr.index[1416:1440], axis=0)
+        if len(self.pwr_yr.index) == 8784:
             print("removing leap day from power year")
-            self.pwr_yr = self.power_hour.drop(self.power_hour.index[1416:1440], axis=0)
-
-    def get_typical_year(self):
-        # Construct a dummy TimeStamp index for the typical year
-        typical_year = pd.date_range('2015-01-01', periods=8760, freq='H')
+            self.pwr_yr = self.pwr_yr.drop(self.pwr_yr.index[1416:1440], axis=0)
 
     def align_data(self):
         """
-        Determine if there is a year of overlapping data, else, 
+        Determine if there is a year of overlapping data, else,
         calculate a typical year of data. Return single data frame
         of met and power on same time axis.
         """
         self.resample_timeseries()
-        self.remove_leap_day()
         if self.determine_overlap() and self.determine_amt_overlap():
+            print("Calcuating Concurrent Year")
             self.calculate_same_year()
+            self.calculate_typical_year()
         else:
+            print("Calcutating Typical Year")
             self.calculate_typical_year()
-        return pd.concat([self.met_hour, self.power_hour],axis = 1)
+        return pd.concat([self.met_yr, self.pwr_yr], axis=1)
 

students/eowyn/windrevenue/windrevenue/parse_met_data.py

@@ -25,12 +25,6 @@ def __init__(self, fname=None, pct=None):
     def setPct(self, pct):
         self.pct = pct
 
-    # Round float value n to nearest precision
-    # https://stackoverflow.com/questions/4265546/python-round-to-nearest-05
-    def round_to_05(n, precision=0.5):
-        correction = 0.5 if n >= 0 else -0.5
-        return int( n/precision+correction ) * precision
-
     def parse_met_file(self, fname=None):
         """
         Read met data file, store in data frame and store sensor choice
@@ -53,13 +47,8 @@ def get_met_timeseries(self):
         currentdf = currentdf.dropna(axis=0, how='any')
         return currentdf
 
-    def dummy_function(self, fname=os.path.abspath("sample_data/sample_met.txt")):
-        filename = input("Full path to met file (leave blank to use sample data):\n")
-        fname = filename or fname
-
     def load_new(self, fname):
-        # Use sample data, or else read data from file provided by user
-        filename = None
+        # Read met data from file into data frame self.metdf
         print("Reading met file: ", fname)
         metdf = pd.read_table(fname, skiprows=1,
                               index_col=0,

students/eowyn/windrevenue/windrevenue/peakhours.py

@@ -8,39 +8,48 @@
 """
 import pandas as pd
 
+
 class PeakHours():
 
-    def __init__(self):
-        self.peakHours = pd.Series([i for i in range(0, 12)])  # 0..11
-        self.offPeakHours = pd.Series([i for i in range(12, 24)])  # 12..23
+    def __init__(self, peak=None, offpeak=None):
+        # PeakHours instances contain series of peak and off peak hours
+        # By default those are 0-11 and 12-23, respectively
+        # No restriction is made on the hours, but they should be lists
+        if peak is not None:
+            self.peak_hours = pd.Series(peak)
+        else:
+            self.peak_hours = pd.Series([i for i in range(0, 12)])  # 0..11
+        if offpeak is not None:
+            self.off_peak_hours = pd.Series(offpeak)
+        else:
+            self.off_peak_hours = pd.Series([i for i in range(12, 24)])  # 12..23
 
     def print_peak_hours(self):
-        print("Peak hours: ", self.peakHours)
-        print("Off-Peak hours: ", self.offPeakHours)
+        print("Peak hours: ", self.peak_hours)
+        print("Off-Peak hours: ", self.off_peak_hours)
 
     def get_peak_hours(self):
-        return (self.peakHours, self.offPeakHours)
+        return (self.peak_hours, self.off_peak_hours)
 
     def set_peak_hours(self):
         """
         Ask user to specify peak hours. Parse the input.
         Off-Peak are all the
-        other hours on 24-hour basis. Set attributes for peak/offPeakHours
+        other hours on 24-hour basis. Set attributes for peak/off_peak_hours
         """
-        choice = input("Enter peak hours (1-24) as list or range e.g.1,3,5-9\n")
+
+        choice = input("Enter peak hours (0-23) as list or range e.g.1,3,5-9\n")
         parsed = [i.split('-') for i in choice.split(',')]
-        print(parsed)
         flat = set()
-        print(flat)
         for elem in parsed:
             if len(elem) == 2:
-                inclusive = set([i for i in range(int(elem[0]),int(elem[1])+1)])
+                inclusive = set([i for i in range(int(elem[0]), int(elem[1])+1)])
                 flat = flat.union(inclusive)
             else:
                 flat.update([int(elem[0])])
         allhours = [i + 1 for i in range(0, 24)]
-        self.offPeakHours = list(set(allhours).difference(flat))
-        self.peakHours = list(flat)
+        self.off_peak_hours = list(set(allhours).difference(flat))
+        self.peak_hours = list(flat)
 
 
 

students/eowyn/windrevenue/windrevenue/revenue.py

@@ -12,15 +12,86 @@
 
 import pandas as pd
 import numpy as np
+from windrevenue.peakhours import PeakHours
+from windrevenue.align_data import AlignData
 
 
-def GrossRevenue():
+class GrossRevenue():
+    """
+    Generate monthly tables of gross revenue given a data frame of
+    aligned (1-year, Jan - Dec) pricing and generation data. Include
+    wind speed in the final tables that are printed and written
+    to .csv file.
+    """
 
-    def calculate_revenue(self):
+    def __init__(self, aligned_data, peak_hours=None):
         """
+        Require aligned pricing and generation data in AlignData obj
+        Optionally, accept PeakHours object. Otherwise create one
+        using default parameters.d
+        """
+        if peak_hours is not None:
+            self.peak_hours = peak_hours
+        else:
+            self.peak_hours = PeakHours()
+        self.aligned_data = aligned_data
+
+    def add_revenue_column(self, scale=1e-4):
+        """
+        ALignedData has 3 columns, wind speed, generation, and price
+        Append a column with the gross revenue, scaling input power to
+        MWh (default 1e-4)
+        """
+        colnames = list(self.aligned_data)
+        pricevar, genvar = colnames[1], colnames[2]
+        revenue = scale * self.aligned_data[genvar] * self.aligned_data[pricevar]
+        self.aligned_data["Revenue"] = revenue
+
+    def subset_data(self, subset_on="peak"):
+        """
+        Return a dataframe containing only peak, or off-peak, times
+        as determined by the arg "subset_on" which can be "peak" or
+        "off-peak", with "peak" as the default. Other times are NaN
+        """
+        subset_on = subset_on.strip().lower()
+        hrsoptions = self.peak_hours.get_peak_hours()  # Peak & off-peak
+        # Select peak or off peak hours
+        if subset_on == "peak":
+            hours = hrsoptions[0]
+        elif subset_on == "off-peak":
+            hours = hrsoptions[1]
+        else:
+            raise(UserWarning, "Selection must be peak or off-peak")
+        # Construct timeseries of 1, NaN for times included,excluded
+        include_times = pd.Series(self.aligned_data.index.hour).isin(hours)
+        # Set up time index to match aligned_data so we can mask
+        include_times.index = AlignData.get_typical_year()
+        include_times.index.names = ["TimeStamp"]
+        include_times = include_times.apply(lambda x: 1 if x else np.nan)
+        # Mask aligned_data to NaN-out excluded times
+        return self.aligned_data.mul(include_times, axis=0)
 
-        :param self:
-        :return:
+    def group_data(self, input_df):
+        """
+        Return a dataframe of the data grouped by month, and hour
+        of day (latter is inherent in aligned_data) for a dataframe
+        of windspeed, generation, price, and revenue. Average the
+        windspeed and price; sum generation and revenue.
         """
         pass
 
+    def save_pretty_table(self, outputfile="sample_output.csv"):
+        """
+        Save a pretty table of results to outputfile (.csv)
+        """
+        pass
+
+    def print_pretty_table(self):
+        """
+        Print a pretty table of results to stdout
+        """
+        pass
+
+
+
+

students/eowyn/windrevenue/windrevenue/test/bck_pc_test.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+
+import os
+import unittest
+
+from windrevenue.UI import UI
+from windrevenue.power_curve_tool import PowerCurve
+
+pcfile = os.path.abspath("../windrevenue/sample_data/power_curve.txt")
+windbins = [2.5, 3.0, 3.5, 4.0,
+            4.5, 5.0, 5.5, 6.0,
+            6.5, 7.0, 7.5, 8.0,
+            8.5, 9.0, 9.5, 10.0,
+            10.5, 11.0, 11.5, 12.0,
+            12.5, 13.0, 13.5, 14.0,
+            14.5, 15.0, 15.5, 16.0,
+            16.5, 17.0, 17.5, 18.0,
+            18.5, 19.0, 19.5, 20.0]
+
+def test_powercurve_init_with_fname():
+    pc = PowerCurve(fname=pcfile)
+    assert pc.power_curve[2.5] == 10
+    assert pc.power_curve[7] == 1400
+
+class InputFeeder():
+    def __init__(self, input_lines):
+        self.index = 0
+        self.input_lines = input_lines
+
+    def get_user_input(self, prompt_string):
+        if self.index >= len(self.input_lines):
+            return None
+        else:
+            value = self.input_lines[self.index]
+            self.index = self.index + 1
+            return value
+
+def test_load_powercurve_with_ui(capsys):
+    input_lines = ["2", "3", pcfile, "4", "6"]
+    input_feeder = InputFeeder(input_lines)
+    from unittest import mock
+    import builtins
+    # with capsys.disabled():
+    with mock.patch.object(UI, 'get_user_input', input_feeder.get_user_input):
+        ui = UI()
+        import pytest
+        with pytest.raises(SystemExit) as pytest_wrapped_e:
+            ui.mainloop()
+            assert pytest_wrapped_e.type == SystemExit
+            assert pytest_wrapped_e.value.code == 42
+        captured = capsys.readouterr()
+        assert "Reading power curve file" in captured.out
+        # assert "Thank you, Kenny Powers, for your generosity and recent gift of $1000000.00.\n" == captured.out
+        assert "" == captured.err
+        print(captured.out)
+
+