Lint according to PEP8

Author: rht

contract.py

@@ -6,12 +6,11 @@
 
 
 class Contract:
-    def __init__(self, contract_partners, endtime = None):
+    def __init__(self, contract_partners, endtime=None):
         self.contract_partners = contract_partners
         self.obligations = {}
         self.endtime = endtime
-        self.valid = True 
-
+        self.valid = True
 
     @staticmethod
     def generated(contract_dict):
@@ -43,17 +42,17 @@ def fulfill_obligation(self, me, von, to, delivery):
         """ over delivery is handled quietly """
         for good, amount in delivery.items():
             try:
-                #me.destroy(good, amount)
+                # me.destroy(good, amount)
                 me.give(self.contract_partners[to][0], self.contract_partners[to][1], good, amount)
                 self.obligations[von][good] = max(0, self.obligations[von][good] - amount)
             except NotEnoughGoods:
                 raise
 
     def terminate(self):
         self.valid = False
-        
+
     def is_valid(self):
         return self.valid
-        
+
     def get_endtime(self):
         return self.endtime

expectedvaluemc.py

@@ -11,34 +11,33 @@
 >>> getEV(GeneralizedExponential(33.33), 10, None, 40., None)
 >>> getEV(GeneralizedExponential(33.33), 10, 4., None, 4.)
 """
+
+
 def getEV(dist, sampleSize=1000, min=None, max=None, defaultVal=None):
-    rvs = populateArray(dist, sampleSize, min, max, defaultVal);
+    rvs = populateArray(dist, sampleSize, min, max, defaultVal)
     return sum(rvs) / len(rvs)
 
+
 def populateArray(dist, sampleSize, min, max, defaultVal):
     """ Create new instance of RandomEngine with new seed, otherwise
     duplicates in the rvs of successive method calls are possible. """
-    if defaultVal is None :
+    if defaultVal is None:
         rvs = []
         while len(rvs) < sampleSize:
-                # HELP IntStream.range(0, sampleSize - rvs.size()).forEach($ -> rvs.add(dist.random(randomE)));
-            rvs = dist.rvs(sampleSize - len(rvs)) # inefficient
-                # If the distribution has boundaries without default
-                # value to fall back to, delete rvs outside the
-                # boundaries, new ones will be drawn in the next iteration.
+            # HELP IntStream.range(0, sampleSize - rvs.size()).forEach($ -> rvs.add(dist.random(randomE)));
+            rvs = dist.rvs(sampleSize - len(rvs))  # inefficient
+            # If the distribution has boundaries without default
+            # value to fall back to, delete rvs outside the
+            # boundaries, new ones will be drawn in the next iteration.
             if min is not None:
                 rvs = filter(lambda rv: rv < min, rvs)
             if max is not None:
                 rvs = filter(lambda rv: rv > max, rvs)
     else:
         rvs = dist.rvs(sampleSize)
         if min is not None:
-            rvs = [rv if rv >= min else defaultVal for rv in rvs] # SHOULD THAT NOT BE 0?
+            rvs = [rv if rv >= min else defaultVal for rv in rvs]  # SHOULD THAT NOT BE 0?
         if max is not None:
             rvs = [rv if rv <= max else defaultVal for rv in rvs]
-    
-    return rvs
-
-
-
 
+    return rvs

insurancefirm.py

@@ -17,44 +17,40 @@ def init(self, simulation_parameters, agent_parameters):
         self.create('money', simulation_parameters['start_cash_insurer'])
         self.contracts = []
 
-
     def quote(self):
         for request in self.get_messages('request_insurancequote'):
             self.message(request.sender_group, request.sender_id, 'insurancequotes', self.acceptInsuranceContract(request.content))
 
     def acceptInsuranceContract(self, request):
-        return self.riskmodel.evaluate(request['runtime'], request['excess'] , request['deductible'])
+        return self.riskmodel.evaluate(request['runtime'], request['excess'], request['deductible'])
 
     def add_contract(self):
         for contract in self.get_messages('addcontract'):
             self.contracts.append(InsuranceContract.generated(contract.content))
 
     def filobl(self):
-        insurance_payouts = 0 
+        insurance_payouts = 0
         for contract in self.contracts:
-            
             current_payout = contract.get_obligation('insurer', 'money')
-            
             if current_payout > 0:
                 contract.fulfill_obligation(self,
                                             von='insurer',
                                             to='policyholder',
                                             delivery={'money': current_payout})
                 insurance_payouts += current_payout
-                #print("DEBUG: Booked claim payout ", current_payout)
-        
+                # print("DEBUG: Booked claim payout ", current_payout)
         self.log('insurancepayouts', insurance_payouts)
         self.log('money', self.possession('money'))
         self.log('num_contracts', len(self.contracts))
 
     def mature_contracts(self):
-        #for contract in self.contracts:
+        # for contract in self.contracts:
         #    print(type(contract), contract)
         #    #contract.is_valid()
-        
-        #[contract.terminate() for contract in self.contracts if (contract.end_time < self.round)]
-        #self.contracts = [contract for contract in self.contracts if (contract.end_time >= self.round)]
-        
+
+        # [contract.terminate() for contract in self.contracts if (contract.end_time < self.round)]
+        # self.contracts = [contract for contract in self.contracts if (contract.end_time >= self.round)]
+
         [contract.terminate() for contract in self.contracts if (contract.get_endtime() < self.round)]
         self.contracts = [contract for contract in self.contracts if (contract.is_valid())]
 

riskmodel.py

@@ -1,16 +1,15 @@
-#/**
 # * Created by Torsten Heinrich
-# */
 # Translated to python by Davoud Taghawi-Nejad
 import expectedvaluemc
-#from generalizedpareto import GeneralizedPareto
-#from generalizedexponential import GeneralizedExponential
+# from generalizedpareto import GeneralizedPareto
+# from generalizedexponential import GeneralizedExponential
 import scipy.stats
 
+
 class RiskModel:
     def __init__(self,
                  riskDistribution=scipy.stats.pareto(2., 0., 10.),
-                 riskPeriod=scipy.stats.expon(0, 100./3.)):
+                 riskPeriod=scipy.stats.expon(0, 100. / 3.)):
         """
           setting default distributions:
              Power Law with x_min = 10.
@@ -19,16 +18,16 @@ def __init__(self,
              Exponential with lambda = .03
                         => PDF(x) = 0.03 * e^(-0.03*x)
         """
-        self.riskDistribution = riskDistribution;
-        self.riskPeriod = riskPeriod;
+        self.riskDistribution = riskDistribution
+        self.riskPeriod = riskPeriod
 
     # def getDistributionPPF(self, tailSize):
     #     """ allows to check for expected size of 1/x period (e.g. 1/200 year) events ... and to compute expected value (.5)"""
     #     return self.riskDistribution.quantile(tailSize);
 
     def getPPF(self, tailSize):
         """alias of getDistributionPPF """
-        return self.riskDistribution.ppf(tailSize);		#TODO: correct syntax?
+        return self.riskDistribution.ppf(tailSize)  # TODO: correct syntax?
 
     # def getPeriodPPF(self, tailSize):
     #     """ allows to compute expected value (.5)"""
@@ -43,11 +42,9 @@ def evaluate(self, runtime, excess, deductible, expectedReturn=.15):
         and risk period /riskPeriod.mean * riskDistribution.mean * runtime -
         deductible = riskFreq.mean * riskDistribution.mean * runtime - deductible """
 
+        distributionExpectedValue = expectedvaluemc.getEV(self.riskDistribution, 1000, None, None, excess)
+        periodExpectedValue = expectedvaluemc.getEV(self.riskPeriod, 1000, None, None, None)
 
-        distributionExpectedValue = expectedvaluemc.getEV(self.riskDistribution, 1000, None, None, excess);
-        periodExpectedValue = expectedvaluemc.getEV(self.riskPeriod, 1000, None, None, None);
-
-        expectedLoss = distributionExpectedValue * (1./periodExpectedValue) * runtime - deductible;
-        #print("DEBUG  **RM", distributionExpectedValue, periodExpectedValue, expectedLoss, expectedReturn, expectedLoss * (1. + expectedReturn))
-        return expectedLoss * (1. + expectedReturn);
-
+        expectedLoss = distributionExpectedValue * (1. / periodExpectedValue) * runtime - deductible
+        # print("DEBUG  **RM", distributionExpectedValue, periodExpectedValue, expectedLoss, expectedReturn, expectedLoss * (1. + expectedReturn))
+        return expectedLoss * (1. + expectedReturn)