feat: Exercise #5. Python Standard Library

BREAKING CHANGE: Exercise added

Author: NicolasOmar

5-standard-library/blockchain.py

@@ -0,0 +1,194 @@
+# A built in module that provides functions from python standard library
+import functools
+import collections
+
+from utils import hash_block, hash_string_256
+
+MINING_REWARD = 10
+genesis_block = {
+    'previous_hash': '',
+    'index': 0,
+    'transactions': [],
+    'proof': 100
+}
+my_blockchain = [genesis_block]
+open_transactions = []
+waiting_for_input = True
+owner = 'Nicolas'
+participants = set([owner])
+
+def add__line():
+    print('------------------------------')
+
+def generate_options_menu():
+    add__line()
+    print('Please choose an option:')
+    print('1: Add a new transaction')
+    print('2: Mine a new block')
+    print('3: Output all blockchain blocks')
+    print('4: Output all participants')
+    print('h: Manipulate blockchain')
+    print('q: Quit')
+    add__line()
+
+def get_user_input():
+    user_input = input('Please enter your selection: ')
+    add__line()
+    return user_input
+
+def valid_proof(transactions, last_hash, proof):
+    guess = (str(transactions) + str(last_hash) + str(proof)).encode()
+    guess_hash = hash_string_256(guess)
+    # If the hash starts with 2 leading zeros, we consider it a valid proof
+    return guess_hash[0:2] == '00'
+
+def proof_of_work():
+    last_block = my_blockchain[-1]
+    hash_last_block = hash_block(last_block)
+    proof = 0
+    while not valid_proof(open_transactions, hash_last_block, proof):
+        proof += 1
+    return proof
+
+
+
+def mine_block():
+    last_block = my_blockchain[-1]
+    hashed_block = hash_block(last_block)
+    proof_of_work_value = proof_of_work()
+
+    # Old way to create a mining reward transaction, it will be replaced by an OrderedDict to keep the order of the elements
+        # reward_transaction = {
+        #     'sender': 'MINING',
+        #     'recipient': owner,
+        #     'amount': MINING_REWARD
+        # }
+    reward_transaction = collections.OrderedDict([('sender', 'MINING'), ('recipient', owner), ('amount', MINING_REWARD)])
+
+    block = {
+        'previous_hash': hashed_block,
+        'index': len(my_blockchain),
+        'transactions': [open_transactions, reward_transaction],
+        'proof': proof_of_work_value
+    }
+    
+    my_blockchain.append(block)
+    print('Block added!')
+    add__line()
+    return True
+
+def get_transaction_value():
+    """ Returns the input of the user (a new transaction amount and its recipient) as a tuple """
+    tx_recipient_input = input('Please enter the recipient of the transaction: ')
+    tx_amount_input = float(input('Please enter your transaction input: '))
+    add__line()
+
+    return tx_recipient_input, tx_amount_input
+
+def take_last_blockchain_value():
+    if len(my_blockchain) < 1:
+        return None
+    
+    return my_blockchain[-1]
+
+def verify_transaction(transaction):
+    sender_balance = get_balance(transaction['sender'])
+    
+    if sender_balance >= transaction['amount']:
+        return True
+    return False
+
+def add_transaction(sender, recipient, amount=1):
+    """
+        Add a new transaction to the list of open transactions (which will be added to the next mined block)
+
+        Arguments:
+            :sender: The sender of the coins.
+            :recipient: The recipient of the coins.
+            :amount: The amount of the transaction.
+    """
+
+    # An old way to create a transaction, it will be replaced by an OrderedDict to keep the order of the elements
+        # new_transaction = {
+        #     'sender': sender,
+        #     'recipient': recipient,
+        #     'amount': amount
+        # }
+    new_transaction = collections.OrderedDict([('sender', sender), ('recipient', recipient), ('amount', amount)])
+
+    if verify_transaction(new_transaction):
+        open_transactions.append(new_transaction)
+        participants.add(sender)
+        participants.add(recipient)
+    else:
+        print('Transaction failed! Not enough balance!')
+    add__line()
+
+def return_all_blocks():
+    print('---Outputting all blocks---')
+    
+    for block in my_blockchain:
+        print(f'Outputting block: {block}')
+    add__line()
+    
+def get_balance(participant):
+    sent_transactions = [[tx['amount'] for tx in block['transactions'] if tx['sender'] == participant] for block in my_blockchain]
+    recieved_transactions = [[tx['amount'] for tx in block['transactions'] if tx['recipient'] == participant] for block in my_blockchain]
+    open_sent_transactions = [tx['amount'] for tx in open_transactions if tx['sender'] == participant]
+
+    sent_transactions.append(open_sent_transactions)
+    sent_amounts = functools.reduce(lambda tx_sum, tx_amt: tx_sum + sum(tx_amt) if len(tx_amt) > 0 else tx_amt + 0, sent_transactions, 0)
+    
+    recieved_amounts = functools.reduce(lambda tx_sum, tx_amt: tx_sum + sum(tx_amt) if len(tx_amt) > 0 else tx_amt + 0, recieved_transactions, 0)
+    
+    return recieved_amounts - sent_amounts
+
+def verify_chain():
+    """ The function helps to verify the integrity of the blockchain by checking if each block's previous hash matches the hash of the previous block. """
+    for (index, block) in enumerate(my_blockchain):
+        if index == 0:
+            continue
+        if block['previous_hash'] != hash_block(my_blockchain[index - 1]):
+            return False
+        # You are cheking all the transactions except the last one because the last one is the mining reward transaction
+        if not valid_proof(block['transactions'][:-1], block['previous_hash'], block['proof']):
+            print('Proof of work is invalid')
+            return False
+    return True
+
+def verify_transactions():
+    """ The function verifies all open transactions to ensure they are valid. """
+    return all([tx for tx in open_transactions if not verify_transaction(tx)])
+
+while waiting_for_input:
+    generate_options_menu()
+    
+    user_choice = get_user_input()
+    
+    if user_choice == '1':
+        tx_input_data = get_transaction_value()
+        recipient, amount = tx_input_data
+        add_transaction(owner, recipient, amount)
+    elif user_choice == '2':
+        if mine_block():
+            open_transactions = []
+    elif user_choice == '3':
+        return_all_blocks()
+    elif user_choice == '4':
+        print(participants)
+    elif user_choice == 'q':
+        waiting_for_input = False
+    elif user_choice == 'h':
+        if len(my_blockchain) >= 1:
+            my_blockchain[0] = [2.0]
+    else:
+        print('Invalid input, please choose a valid option')
+    if not verify_chain():
+        print('Invalid blockchain!')
+        waiting_for_input = False
+    print(f"Balance of {owner}: {get_balance(owner)}")
+else:
+    print('User left!')
+
+add__line()
+print('Done!')

5-standard-library/exercise.py

@@ -0,0 +1,29 @@
+def add__line():
+    print('--------------------')
+    
+# 1) Import the random function and generate both a random number between 0 and 1 as well as a random number between 1 and 10.
+import random
+
+def generate_random_number():
+    first_random_number = random.randrange(0, 10)
+    second_random_number = random.randint(1, 10)
+    return first_random_number, second_random_number
+
+print(generate_random_number())
+print(generate_random_number())
+print(generate_random_number())
+add__line()
+
+# 2) Use the datetime library together with the random number to generate a random, unique value.
+import datetime
+
+def generate_unique_value_from_datetime():
+  current_date_time = datetime.datetime.now()
+  random_number = random.randint(1, 1000)
+  unique_value = f"{current_date_time.year}{current_date_time.month}{current_date_time.day}{current_date_time.hour}{current_date_time.minute}{current_date_time.second}{random_number}"
+  return unique_value
+
+print(generate_unique_value_from_datetime())
+print(generate_unique_value_from_datetime())
+print(generate_unique_value_from_datetime())
+add__line()

5-standard-library/theory.py

@@ -0,0 +1,9 @@
+# ---IMPORT---
+
+# Importing modules are similar to how is implemented in javascript
+# For example, if you have a file named random.py you can import it like this:
+  # import random
+# You can also import it with an alias like this:
+  # import random as r
+# Or you can import specific functions (like randint and shuffle) from a module like this:
+  # from random import randint, shuffle

5-standard-library/utils.py

@@ -0,0 +1,17 @@
+# Hashing functions are provided by the hashlib module
+import hashlib
+# The json module allows us to convert python objects into json strings (including structures such as lists and dictionaries)
+import json
+
+def hash_string_256(string):
+    """ Hash a string using sha256 """
+    return hashlib.sha256(string).hexdigest()
+
+def hash_block(block):
+    """ Hash a block using its strucutre as base """
+    # On this case, first we are going to convert the block into a json string
+    # Then we are going to encode it to bytes with the enconde function
+    encoded_block = json.dumps(block, sort_keys=True).encode()
+    # And at last, we are going to return the hashed block using sha256
+    # but converted into a hexadecimal string (for easier reading)
+    return hash_string_256(encoded_block)

README.md

@@ -30,8 +30,14 @@ cd python-practice
 ```
 
 ## How to run it
+Each folder might have the following files:
+- `theory.py` for concepts explanation.
+- `blockchain.py` for improvements in course's main exercise.
+- `exercise.py` related to subject's learned lessons.
+
 To run any specific exercise, execute the following command in the project´s folder:
 ```python
+cd folder_name
 python3 exercise.py # Or any .py file
 ```
 
@@ -65,6 +71,9 @@ python3 exercise.py # Or any .py file
   - How to use string interpolation with the `f` method.
   - How to map lists with map method and `lambda functions`.
   - How to summarize data with `reduce` method.
+- Standard Library (`5-standard-library` folder)
+  - Understanding the ways to import built-in functions from [Python Standard Library](https://docs.python.org/3/library/index.html).
+  - Learn how to split functions in other files and import them.
 
 ## Other practice repos
 | Node | React | Angular | GraphQL | HTML & CSS | Styling | Typescript | NextJs | Docker |