Prepare to revert

estimate_grid_mv_line_budget_in_meters.py

@@ -1,7 +1,21 @@
+from invisibleroads_macros.configuration import TerseArgumentParser
 
-# coding: utf-8
+from infrastructure_planning.macros import load_and_run
 
-# In[1]:
+"""
+from infrastructure_planning.demography.exponential import estimate_population
+"""
 
-print('whee')
 
+def add_arguments_for_estimate_population(x):
+    x.add('demand_point_table_path')
+    x.add('population_year')
+    x.add('population_growth_as_percent_of_population_per_year')
+    x.add('financing_year')
+    x.add('time_horizon_in_years')
+
+
+if __name__ == '__main__':
+    x = TerseArgumentParser()
+    add_arguments_for_estimate_population(x)
+    load_and_run(x)

forecast_electricity_consumption.py

@@ -120,8 +120,7 @@ def estimate_electricity_consumption_per_capita(target_year, country_name):
     t = ELECTRICITY_CONSUMPTION_PER_CAPITA_BY_YEAR_TABLE
     country_t = _get_country_table(t, 'Country Name', country_name)
     if not len(country_t):
-        raise InvalidData(
-            'missing electricity_consumption_per_capita country_name')
+        raise InvalidData('missing country_name')
     year_packs = []
     for column_name in country_t.columns:
         try:
@@ -133,8 +132,7 @@ def estimate_electricity_consumption_per_capita(target_year, country_name):
             continue
         year_packs.append((year, value))
     if not year_packs:
-        raise InvalidData(
-            'missing electricity_consumption_per_capita year_value')
+        raise InvalidData('missing year_value')
     estimate_electricity_consumption_per_capita = \
         get_interpolated_spline_extrapolated_linear_function(year_packs)
     return estimate_electricity_consumption_per_capita(target_year)

infrastructure_planning/demography/exponential.py

@@ -1,13 +1,6 @@
 from pandas import Series
 
-from ..exceptions import InfrastructurePlanningError
-
-
-M = {
-    'bad_financing_year':
-        'financing year (%s) must be greater than or equal to '
-        'population year (%s)',
-}
+from ..exceptions import ValidationError
 
 
 def estimate_population(
@@ -17,8 +10,8 @@ def estimate_population(
         financing_year,
         time_horizon_in_years):
     if financing_year < population_year:
-        raise InfrastructurePlanningError('financing_year', M[
-            'bad_financing_year'] % (financing_year, population_year))
+        raise ValidationError(
+            'financing_year', 'cannot be less than population_year')
     # Compute the population at financing_year
     base_population = _grow_exponentially(
         population, population_growth_as_percent_of_population_per_year,

infrastructure_planning/electricity/cost/grid.py

@@ -1,7 +1,7 @@
 from geopy.distance import vincenty as get_distance
 from invisibleroads_macros.math import divide_safely
 
-from ...exceptions import ExpectedPositive, InfrastructurePlanningError
+from ...exceptions import ExpectedPositive, ValidationError
 from ...finance.valuation import compute_discounted_cash_flow
 from ...production import adjust_for_losses, prepare_system_cost
 from .mini_grid import estimate_lv_connection_cost, estimate_lv_line_cost
@@ -56,10 +56,9 @@ def estimate_electricity_production_cost(
         grid_mv_transformer_load_power_factor,
         grid_electricity_production_cost_per_kwh):
     if not -1 <= grid_mv_transformer_load_power_factor <= 1:
-        raise InfrastructurePlanningError(
-            'grid_mv_transformer_load_power_factor', (
-                'power factor (%s) must be between '
-                '-1 and 1' % grid_mv_transformer_load_power_factor))
+        raise ValidationError(
+            'grid_mv_transformer_load_power_factor',
+            'must be between -1 and +1')
     production_in_kwh_by_year = adjust_for_losses(
         consumption_in_kwh_by_year,
         grid_system_loss_as_percent_of_total_production / 100.,

infrastructure_planning/exceptions.py

@@ -6,9 +6,21 @@ class InvalidData(InfrastructurePlanningError):
     pass
 
 
-class ExpectedPositive(InvalidData):
+class UnsupportedFormat(InfrastructurePlanningError):
     pass
 
 
-class UnsupportedFormat(InfrastructurePlanningError):
-    pass
+class ValidationError(InfrastructurePlanningError):
+
+    def __init__(self, argument_name, error_message):
+        self.argument_name = argument_name
+        self.error_message = error_message
+        text = '%s.error = %s' % (argument_name, error_message)
+        self.args = (text,)
+
+
+class ExpectedPositive(ValidationError):
+
+    def __init__(self, argument_name):
+        super(ExpectedPositive, self).__init__(
+            argument_name, 'must be greater than or equal to zero')