Merge pull request #9 from MarcPartensky/makefile

makefile update

Makefile

@@ -0,0 +1,9 @@
+start:
+	./app.py -p 8000
+update:
+	pipenv update
+	pipenv lock -r > requirements.txt
+build: update
+	docker-compose build node
+push: build
+	docker-compose push node

app.py

@@ -1,11 +1,12 @@
 #!/usr/bin/env python
+"""Flask server to serve the block API."""
 
-from time import time
-from flask import Flask, request
 import json
-from uuid import uuid4
-from blockchain import Blockchain, Transaction, Block
+from time import time
 import argparse
+from uuid import uuid4
+from flask import Flask, request
+from blockchain import Blockchain, Transaction, Block
 
 parser = argparse.ArgumentParser(description="A blockchain simulation")
 parser.add_argument("-p", "--port", type=int, help="Port number", default=80)
@@ -15,18 +16,19 @@ port = args.port
 
 app = Flask(__name__)
 
-node_identifier = str(uuid4()).replace("-", "")
+NODE_IDENTIFIER = str(uuid4()).replace("-", "")
 
 blockchain = Blockchain()
 
 
 @app.route("/mine", methods=["GET"])
 def mine():
+    """Mine Samycoin."""
     last_block = blockchain.blocks[-1]
     last_proof = last_block.proof
     proof = blockchain.proof_of_work(last_proof)
 
-    transaction = Transaction("Network", node_identifier, 50)
+    transaction = Transaction("Network", NODE_IDENTIFIER, 50)
     blockchain.new_transaction(transaction)
     block = Block(
         len(blockchain.blocks) + 1,
@@ -42,6 +44,7 @@ def mine():
 
 @app.route("/transactions/new", methods=["POST"])
 def new_transaction():
+    """Submit a new transaction."""
     values = request.get_json()
     transaction = Transaction(values["sender"], values["recipient"], values["amount"])
     blockchain.new_transaction(transaction)
@@ -51,27 +54,29 @@ def new_transaction():
 
 @app.route("/chain", methods=["GET"])
 def chain():
+    """Display the block chain."""
     return json.dumps([b.__dict__ for b in blockchain.blocks])
 
 
 @app.route("/nodes", methods=["GET"])
 def nodes():
+    """List known nodes."""
     return json.dumps(list(blockchain.nodes))
 
 
 @app.route("/register", methods=["POST"])
 def register_nodes():
-    values = request.get_json()
-    nodes = values["nodes"]
-
-    for node in nodes:
+    """Register a new node."""
+    json_values = request.get_json()
+    for node in json_values["nodes"]:
         blockchain.register_node(node)
 
     return "New node has been added\n"
 
 
 @app.route("/resolve", methods=["GET"])
-def consensus():
+def resolve():
+    """Resolve the blockchain."""
     replaced = blockchain.resolve_conflicts()
 
     if replaced:

blockchain.py

@@ -3,13 +3,14 @@
 import hashlib
 from time import time
 import json
-import requests
 from urllib.parse import urlparse
+import requests
 
 DIFFICULTY = 4
 
 
 class Block:
+    """Block of the blockkchain."""
     def __init__(self, index, timestamp, transactions, previous_hash, proof):
         self.index = index
         self.timestamp = timestamp
@@ -19,6 +20,7 @@ class Block:
         self.hash = self.hash()
 
     def hash(self):
+        """Hash the block using sha256."""
         data = self.__dict__
         data["transactions"] = [t.__dict__ for t in self.transactions]
         block_string = json.dumps(data, sort_keys=True).encode()
@@ -29,6 +31,7 @@ class Block:
 
 
 class Transaction:
+    """Transaction class."""
     def __init__(self, sender, recipient, amount):
         self.sender = sender
         self.recipient = recipient
@@ -39,6 +42,7 @@ class Transaction:
 
 
 class Blockchain:
+    """Blockchain class."""
     def __init__(self):
         self.blocks = []
         self.blocks.append(self.create_first_block())
@@ -46,20 +50,25 @@ class Blockchain:
         self.nodes = set()
 
     def register_node(self, address):
+        """Register a new node."""
         parsed_url = urlparse(address).netloc
         self.nodes.add(parsed_url)
 
     def create_first_block(self):
+        """create the initial block."""
         return Block(1, time(), [], 1, 100)
 
     def new_transaction(self, transaction):
+        """Add a new transaction."""
         self.transactions.append(transaction)
 
     def new_block(self, block):
+        """Add a new block."""
         self.transactions = []
         self.blocks.append(block)
 
     def proof_of_work(self, last_proof):
+        """Computes the proof."""
         proof = 0
         while not self.valid_proof(proof, last_proof):
             proof += 1
@@ -67,11 +76,13 @@ class Blockchain:
 
     @staticmethod
     def valid_proof(proof, last_proof):
+        """Tests proof."""
         guess = f"{last_proof}{proof}".encode()
         guess_hash = hashlib.sha256(guess).hexdigest()
         return guess_hash[:DIFFICULTY] == "0" * DIFFICULTY
 
     def valid_chain(self, chain):
+        """Tests the validity of a chain."""
         last_block = chain[0]
         current_index = 1
 
@@ -90,6 +101,7 @@ class Blockchain:
         return True
 
     def json_to_transactions(self, transactions_json):
+        """Converts json to a list of transactions."""
         transactions = [
             Transaction(
                 transaction["sender"],
@@ -102,6 +114,7 @@ class Blockchain:
         return transactions
 
     def json_to_chain(self, chain_json):
+        """Convert json to a chain."""
         chain = [
             Block(
                 block["index"],
@@ -116,6 +129,7 @@ class Blockchain:
         return chain
 
     def resolve_conflicts(self):
+        """Resolve conflicts using the consensus algorithm."""
         neighbours = self.nodes
         new_chain = None
         max_lengh = len(self.blocks)