Merge pull request #180 from erasmospunk/master

fix whitespace errors

lib/bitcoin_rpc.py

@@ -101,4 +101,3 @@ class BitcoinRPC(object):
         else:
             log.info("Cannot find block for %s" % hash_hex)
             defer.returnValue(False)
-            

lib/bitcoin_rpc_manager.py

@@ -73,6 +73,7 @@ class BitcoinRPCManager(object):
             log.debug("Check Height -- Pool %i : %i" % (i,height) )
             if height > curr_height:
                 self.curr_conn = i
+
         defer.returnValue(True)
 
     def _call_raw(self, data):

lib/block_template.py

@@ -57,10 +57,12 @@ class BlockTemplate(halfnode.CBlock):
         txhashes = [None] + [ util.ser_uint256(int(t['hash'], 16)) for t in data['transactions'] ]
         mt = merkletree.MerkleTree(txhashes)
         if settings.COINDAEMON_Reward == 'POW':
-           coinbase = CoinbaseTransactionPOW(self.timestamper, self.coinbaser, data['coinbasevalue'], data['coinbaseaux']['flags'], data['height'],
+            coinbase = CoinbaseTransactionPOW(self.timestamper, self.coinbaser, data['coinbasevalue'],
+                                              data['coinbaseaux']['flags'], data['height'],
                                               settings.COINBASE_EXTRAS)
         else:
-	    coinbase = CoinbaseTransactionPOS(self.timestamper, self.coinbaser, data['coinbasevalue'], data['coinbaseaux']['flags'], data['height'],
+            coinbase = CoinbaseTransactionPOS(self.timestamper, self.coinbaser, data['coinbasevalue'],
+                                              data['coinbaseaux']['flags'], data['height'],
                                               settings.COINBASE_EXTRAS, data['curtime'])
 
         self.height = data['height']

lib/coinbaser.py

@@ -27,7 +27,9 @@ class SimpleCoinbaser(object):
         d = self.bitcoin_rpc.validateaddress(self.address)
         if settings.COINDAEMON_Reward == 'POW':
             d.addCallback(self._POW_address_check)
-	else:   d.addCallback(self._POS_address_check)
+        else:
+            d.addCallback(self._POS_address_check)
+
         d.addErrback(self._failure)
 
     def _POW_address_check(self, result):
@@ -91,7 +93,8 @@ class SimpleCoinbaser(object):
         if settings.COINDAEMON_Reward == 'POW':
             self._validate()
             return util.script_to_address(self.address)
- 	else: return util.script_to_pubkey(self.pubkey)    
+        else:
+            return util.script_to_pubkey(self.pubkey)
                    
     def get_coinbase_data(self):
         return ''

lib/halfnode.py

@@ -255,6 +255,7 @@ class CBlock(object):
         if settings.COINDAEMON_Reward == 'POS':
             self.signature = deser_string(f)
         else: pass
+
     def serialize(self):
         r = []
         r.append(struct.pack("<i", self.nVersion))
@@ -314,16 +315,19 @@ class CBlock(object):
             self.calc_quark()
         else:
             self.calc_sha256()
+
         target = uint256_from_compact(self.nBits)
+
         if settings.COINDAEMON_ALGO == 'scrypt':
             if self.scrypt > target:
-	   	return false
+                return False
         elif settings.COINDAEMON_ALGO == 'quark':
             if self.quark > target:
-                return false
+                return False
         else:
            if self.sha256 > target:
                 return False
+
         hashes = []
         for tx in self.vtx:
             tx.sha256 = None

lib/template_registry.py

@@ -152,7 +152,9 @@ class TemplateRegistry(object):
             diff1 = 0x0000ffff00000000000000000000000000000000000000000000000000000000
         elif settings.COINDAEMON_ALGO == 'quark':
             diff1 = 0x000000ffff000000000000000000000000000000000000000000000000000000
-        else:   diff1 = 0x00000000ffff0000000000000000000000000000000000000000000000000000
+        else:
+            diff1 = 0x00000000ffff0000000000000000000000000000000000000000000000000000
+
         return diff1 / difficulty
     
     def get_job(self, job_id):
@@ -240,7 +242,9 @@ class TemplateRegistry(object):
             hash_bin = yac_scrypt.getPoWHash(''.join([ header_bin[i*4:i*4+4][::-1] for i in range(0, 20) ]), int(ntime, 16))
         elif settings.COINDAEMON_ALGO == 'quark':
             hash_bin = quark_hash.getPoWHash(''.join([ header_bin[i*4:i*4+4][::-1] for i in range(0, 20) ]))
-	else: 	hash_bin = util.doublesha(''.join([ header_bin[i*4:i*4+4][::-1] for i in range(0, 20) ]))
+        else:
+            hash_bin = util.doublesha(''.join([ header_bin[i*4:i*4+4][::-1] for i in range(0, 20) ]))
+
         hash_int = util.uint256_from_str(hash_bin)
         scrypt_hash_hex = "%064x" % hash_int
         header_hex = binascii.hexlify(header_bin)

mining/DBInterface.py

@@ -67,12 +67,12 @@ class DBInterface():
             import DB_None
             return DB_None.DB_None()
 
-
     def scheduleImport(self):
         # This schedule's the Import
         if settings.DATABASE_DRIVER == "sqlite":
             use_thread = False
-	else:   use_thread = True
+        else:
+            use_thread = True
         
         if use_thread:
             self.queueclock = reactor.callLater(settings.DB_LOADER_CHECKTIME , self.run_import_thread)

mining/DB_Mysql.py

@@ -155,13 +155,13 @@ class DB_Mysql():
                   %(lres)s, %(result)s, %(reason)s, %(solution)s)
                 """,
                 {
-                    "time": v[4], 
+                    "time": data[4],
-                    "host": v[6], 
+                    "host": data[6],
-                    "uname": v[0], 
+                    "uname": data[0],
-                    "lres": v[5], 
+                    "lres": data[5],
-                    "result": v[5], 
+                    "result": data[5],
-                    "reason": v[9],
+                    "reason": data[9],
-                    "solution": v[2]
+                    "solution": data[2]
                 }
             )
 

mining/DB_None.py

@@ -54,4 +54,3 @@ class DB_None():
 
     def close(self):
         log.debug("Close Connection")
-	

mining/DB_Sqlite.py

@@ -109,6 +109,7 @@ class DB_Sqlite():
             sqldata = []
             for k,v in checkin_times.items():
                 sqldata.append({'last_checkin':v["time"],'addshares':v["shares"],'addrejects':v["rejects"],'user':k})
+
             self.dbc.executemany("update pool_worker set last_checkin = :last_checkin, total_shares = total_shares + :addshares, " +\
                         "total_rejects = total_rejects + :addrejects where username = :user",sqldata)
         else: