chatchain.py

import gradio as gr
import os
import json
import hashlib
import datetime
from huggingface_hub import (upload_file,HfApi)

import crypt
token_self = os.environ['HF_TOKEN']
api = HfApi(token=token_self)
chain_d="chain1.json"
chain_t="trans1.json"



def get_my_chain_send(sender_name=None):
    global mychain_send
    print(sender_name)
    mes_error = ""
    try:
        r1 = requests.get(f'{main_chain}{sender_name}/{sender_name}.json') 
        
        print (f's={r1.text}')
        mychain_send = chatchain.MyChainSend(chain_load=f'{main_chain}{sender_name}/',load=r1.text)

        response = {'chain': mychain_send.chain,
                'length': len(mychain_send.chain)}
        #print (f'response={response}')
       
            
        message = f"Blockchain loaded from: {main_chain}{sender_name}/{sender_name}.json"
        return response,message
    except Exception:
        message = f"Error loading from: {sender_name}"
        print (message)
        return {"MESSAGE":"Error Loading Chain"},message
        
def get_my_chain_rec(recipient_name=None):
    global mychain_rec
    print(recipient_name)
    try:
        r2 = requests.get(f'{main_chain}{recipient_name}/{recipient_name}.json') 
        print (f'r={r2.text}')
        mychain_rec = MyChainRec(chain_load=f'{main_chain}{recipient_name}/',load=r2.text)
        response = {'chain': mychain_rec.chain,
                'length': len(mychain_rec.chain)}
        message = f"Blockchain loaded from: {main_chain}{recipient_name}/{recipient_name}.json"
        return response,message
    except Exception:
        try:
            mychain_rec = MyChainRec(chain_load=main_chain,create=recipient_name)
            response = {'chain': mychain_rec.chain,
                    'length': len(mychain_rec.chain)}
            
            message = f"Blockchain loaded from: {main_chain}{recipient_name}/{recipient_name}.json"
            return response,message
        except Exception:
            message = f"Error loading from: {recipient_name}"
            return ["Error Loading Chain"],message
        
def display_chain_send():
    response = {'chain': mychain_send.chain,
                'length': len(mychain_send.chain)}
    return response
    
def display_chain_rec():
    response = {'chain': mychain_rec.chain,
                'length': len(mychain_rec.chain)}
    return response
    
def valid_send():
    valid,ind,mes = mychain_send.chain_valid(mychain_send.chain)
    if valid:
        response = 'The Blockchain is valid.'
        z=True
    else:
        response = f'Sender Blockchain is not valid. {mes} at Index {ind}'
        z=False
    return response,z,mes,ind
    
def valid_rec():
    valid,ind,mes = mychain_rec.chain_valid(mychain_rec.chain)
    if valid:
        response = 'The Blockchain is valid.'
        z=True
    else:
        response = f'Blockchain is not valid. {mes} at Index {ind}'
        z=False
    return response,z, mes, ind

def mychain_mine_block_send(chain_r=None,chain_n=None):
    previous_block = mychain_send.print_previous_block()
    previous_proof = previous_block['proof']
    proof = mychain_send.proof_of_work(previous_proof)
    previous_hash = mychain_send.hash(previous_block)
    block = mychain_send.create_block(proof, previous_hash,chain_r,chain_n)

    response = {'message': 'A block is MINED',
                'index': block['index'],
                'timestamp': block['timestamp'],
                'proof': block['proof'],
                'previous_hash': block['previous_hash']
               }
   
    message = "A block is MINED"
    show_chain = display_chain_send()
    
    if len(mychain_send.chain) > 1000:
        mychain_send.reset()
        response = None
        show_chain=display_chain_send()
        message = "New Chain Created at Max 20 Blocks"
    
    return response, show_chain,message

def mychain_mine_block_rec(chain_r=None,chain_n=None):
    previous_block = mychain_rec.print_previous_block()
    previous_proof = previous_block['proof']
    proof = mychain_rec.proof_of_work(previous_proof)
    previous_hash = mychain_rec.hash(previous_block)
    block = mychain_rec.create_block(proof, previous_hash,chain_r,chain_n)

    response = {'message': 'A block is MINED',
                'index': block['index'],
                'timestamp': block['timestamp'],
                'proof': block['proof'],
                'previous_hash': block['previous_hash']
               }
    message = "A block is MINED"
    show_chain = display_chain_rec()
    if len(mychain_rec.chain) > 1000:
        mychain_rec.reset()
        response = None
        show_chain=display_chain_rec()
        message = "New Chain Created at Max 20 Blocks"
    return response, show_chain, message



def store_image(img,chain_load,address):
    main_chain_im=chain_load
    chain_r=f"{main_chain_im.split('datasets/',1)[1].split('/raw',1)[0]}"    
    try: 
        api.upload_file(
        path_or_fileobj=img,
        path_in_repo=f'chat/{address}/{address}.png',
        repo_id=chain_r,
        token=token_self,
        repo_type="dataset",
        )
        #os.remove("tmp_send.json")
    except Exception as e:
        print (f'Error storing image: {e}')
def update_rec_list(main_chain):
    print (main_chain)
    repo = main_chain.split('datasets/',1)[1].split('/raw',1)[0].split('/',1)[0]
    name = main_chain.split('datasets/',1)[1].split('/raw',1)[0].split('/',1)[1]
    f_ist = (api.list_repo_files(repo_id=f'{repo}/{name}', repo_type="dataset"))
    print (f_ist)
    rec_list =[]
    rec_list.clear()
    for i,ea in enumerate(f_ist):
        if "chat/" in ea:
            try:
                if not ".png" in ea:
                    rec_list.append(ea.split("chat/",1)[1].split("/",1)[0])
            except Exception:
                pass
    print (f'REC_LIST : : {rec_list}')
    return rec_list, gr.Dropdown.update(label="Recipient", choices=[f for f in rec_list])

class MyChainSend:

    def __init__(self,chain_load,load=None,create=None):
        global main_chain_send
        main_chain_send=chain_load
        
        self.pending_transactions = []
        if load == None or load=="":
            self.chain = []
            self.create_block(proof=1, previous_hash='0',chain_n=create)
        elif load != None and load !="":
            #r = requests.get(load) 
            lod = json.loads(load)
            self.chain = lod
    def reset(self,create=None):
        self.chain = []
        self.pending_transactions = []
        self.create_block(proof=1, previous_hash='0',chain_n=create)
    def create_block(self, proof, previous_hash,chain_r=None,chain_n=None):
        if chain_r=="" or chain_r==None:
            chain_r=f"{main_chain_send.split('datasets/',1)[1].split('/raw',1)[0]}"
        if chain_n !="" and chain_n !=None:
            chain_n = f"{main_chain_send.split('main/',1)[1]}{chain_n}.json"
            print(f'chain_n send :: {chain_n}')
        if chain_n=="" or chain_n==None:
            chain_n="error_send.json"
        #prev_block = len(blockchain.chain)-1
        #previous_block = blockchain.chain[prev_block]            
        block = {'index': len(self.chain) + 1,
                'timestamp': str(datetime.datetime.now()),
                'message': self.pending_transactions,
                'proof': proof,
                'previous_hash': previous_hash}
        if self.block_valid(block) == True:
            
            self.pending_transactions = []
            self.chain.append(block)
            json_object = json.dumps(self.chain, indent=4)
            with open("tmp_send.json", "w") as outfile:
                outfile.write(json_object)
            outfile.close()
            try: 
                api.upload_file(
                path_or_fileobj="tmp_send.json",
                path_in_repo=f'{chain_n}',
                repo_id=chain_r,
                token=token_self,
                repo_type="dataset",
                )
                os.remove("tmp_send.json")
        
            except Exception as e:
                print(e)
                pass         
            return block
        else:
            block = {"Not Valid"}
            print("not Valid")
            return block
    def print_previous_block(self):
        return self.chain[-1]
    def new_transaction(self, sender, recipient, message,priv_key):
        transaction = {
            'sender': sender,
            'recipient': recipient,
            'message': message,
        }
        transaction = crypt.encrypt_trans(transaction,priv_key)
        self.pending_transactions.append(str(transaction))
    def proof_of_work(self, previous_proof):
        new_proof = 1
        check_proof = False
        while check_proof is False:
            hash_operation = hashlib.sha256(
                str(new_proof**2 - previous_proof**2).encode()).hexdigest()
            if hash_operation[:5] == '00000':
                check_proof = True
            else:
                new_proof += 1
        return new_proof

    def hash(self, block):
        encoded_block = json.dumps(block, sort_keys=True).encode()
        return hashlib.sha256(encoded_block).hexdigest() 
    def block_valid(self, block):
        #print (block)
        #prev_block=len(self.chain)
        if len(self.chain) > 0:
            prev_block = len(self.chain)-1
            previous_block = self.chain[prev_block]
            #print (previous_block)
            out=True
            ind=None
            mes=None
            if block['previous_hash'] != self.hash(previous_block):
                out=False
                #ind=block_index
                mes='Hash'
    
            previous_proof = previous_block['proof']
            proof = block['proof']
            hash_operation = hashlib.sha256(
                str(proof**2 - previous_proof**2).encode()).hexdigest()
    
            if hash_operation[:5] != '00000':
                out=False
                #ind=block_index+1
                mes='Proof'
            previous_block = block
        else: 
            out = True
        return out 

    def chain_valid(self, chain):
        
        previous_block = chain[0]
        block_index = 1 
        out=True
        ind=None
        mes=None
        while block_index < len(chain):
            block = chain[block_index]
            if block['previous_hash'] != self.hash(previous_block):
                out=False
                ind=block_index
                mes='Hash'
                break

            previous_proof = previous_block['proof']
            proof = block['proof']
            hash_operation = hashlib.sha256(
                str(proof**2 - previous_proof**2).encode()).hexdigest()

            if hash_operation[:5] != '00000':
                out=False
                ind=block_index+1
                mes='Proof'
                break
            previous_block = block
            block_index += 1
        
        return out, ind, mes

    def deep_valid_send(self, chain1,chain2):
       
        block_index = 1 
        out=True
        ind=None
        mes=None
        while block_index < len(chain1):
            block = chain1[block_index]
            block_ind = block['block']
            block2 = chain2[block_ind]

            check1 = {
                'timestamp':block['timestamp'],
                'recipient':block['transactions']['recipient'],
                'amount':block['transactions']['amount'],
                'balance':block['transactions']['balance'],
                'balance2':block['balance'],
                'proof':block['proof'],
                'previous_hash':block['previous_hash']
            }
            zz=1
            while zz < len(block2[transactions]):
                
                check2 = {
                    'timestamp':block2['timestamp'],
                    'sender':block2['transactions'][zz][0]['name'],
                    'recipient':block2['transactions'][zz][0]['recipient'],
                    'amount':block2['transactions'][zz][0]['amount'],
                    'balance':block2['transactions'][zz][0]['balance'],
                    'balance2':block2['transactions'][zz][0]['balance'],
                    'proof':block2['proof'],
                    'previous_hash':block2['previous_hash']
                }
                zz+=1
                
            
                if self.hash(check1) != self.hash(check2):
                    out=False
                    ind=block_index
                    mes='Hash'
                    break
            
            if out == False:
                break
            block_index += 1
        
        return out, ind, mes

        

class MyChainRec:

    def __init__(self,chain_load, load=None,create=None,pub_key=None):
        global main_chain_rec
        main_chain_rec=chain_load
        
        self.pending_transactions = []
        if load == None or load=="":
            self.chain = []
            self.create_block(proof=1, previous_hash='0',chain_n=create,pub_key=pub_key)
        if load != None and load !="":
            #r = requests.get(load) 
            lod = json.loads(load)
            self.chain = lod
    def reset(self,create=None):
        self.chain = []
        self.pending_transactions = []
        self.create_block(proof=1, previous_hash='0',chain_n=create)
    def create_block(self, proof, previous_hash,chain_r=None,chain_n=None,pub_key=None):
        if chain_r=="" or chain_r==None:
            chain_r=f"{main_chain_rec.split('datasets/',1)[1].split('/raw',1)[0]}"
        if chain_n !="" and chain_n !=None:
            chain_n = f"{main_chain_rec.split('main/',1)[1]}{chain_n}.json"
        if chain_n=="" or chain_n==None:
            chain_n="error_rec.json"
        print(f'chain_n rec :: {chain_n}')
            
        #prev_block = len(blockchain.chain)-1
        #previous_block = blockchain.chain[prev_block]             
        if pub_key !=None and pub_key!="":
            block = {'index': len(self.chain) + 1,
                    'timestamp': str(datetime.datetime.now()),
                    'message': pub_key,
                    'proof': proof,
                    'previous_hash': previous_hash}
        else:
            block = {'index': len(self.chain) + 1,
                    'timestamp': str(datetime.datetime.now()),
                    'message': self.pending_transactions,
                    'proof': proof,
                    'previous_hash': previous_hash}
        
        if self.block_valid(block) == True:
            self.pending_transactions = []
            self.chain.append(block)
            json_object = json.dumps(self.chain, indent=4)
            with open("tmp_rec.json", "w") as outfile:
                outfile.write(json_object)
            outfile.close()
            try: 
                api.upload_file(
                path_or_fileobj="tmp_rec.json",
                path_in_repo=f'{chain_n}',
                repo_id=chain_r,
                token=token_self,
                repo_type="dataset",
                )
                os.remove("tmp_rec.json")
        
            except Exception as e:
                print(e)
                pass         
            return block
        else:
            block = {"Not Valid"}
            print("not Valid")
            return block
    def print_previous_block(self):
        return self.chain[-1]
    def new_transaction(self, sender, recipient, message,pub_key):
        transaction = {
            'sender': sender,
            'recipient': recipient,
            'message': message,
        }
        transaction = crypt.encrypt_trans(transaction,pub_key)

        self.pending_transactions.append(str(transaction))
    def proof_of_work(self, previous_proof):
        new_proof = 1
        check_proof = False
        while check_proof is False:
            hash_operation = hashlib.sha256(
                str(new_proof**2 - previous_proof**2).encode()).hexdigest()
            if hash_operation[:5] == '00000':
                check_proof = True
            else:
                new_proof += 1
        return new_proof

    def hash(self, block):
        encoded_block = json.dumps(block, sort_keys=True).encode()
        return hashlib.sha256(encoded_block).hexdigest() 
    def block_valid(self, block):
        print (block)
        #prev_block=len(self.chain)
        if len(self.chain) > 0:
            prev_block = len(self.chain)-1
            previous_block = self.chain[prev_block]
            print (previous_block)
            out=True
            ind=None
            mes=None
            if block['previous_hash'] != self.hash(previous_block):
                out=False
                #ind=block_index
                mes='Hash'
    
            previous_proof = previous_block['proof']
            proof = block['proof']
            hash_operation = hashlib.sha256(
                str(proof**2 - previous_proof**2).encode()).hexdigest()
    
            if hash_operation[:5] != '00000':
                out=False
                #ind=block_index+1
                mes='Proof'
            previous_block = block
        else: 
            out = True
        return out 

    def chain_valid(self, chain):
        previous_block = chain[0]
        block_index = 1 
        out=True
        ind=None
        mes=None
        while block_index < len(chain):
            block = chain[block_index]
            if block['previous_hash'] != self.hash(previous_block):
                out=False
                ind=block_index
                mes='Hash'
                break

            previous_proof = previous_block['proof']
            proof = block['proof']
            hash_operation = hashlib.sha256(
                str(proof**2 - previous_proof**2).encode()).hexdigest()

            if hash_operation[:5] != '00000':
                out=False
                ind=block_index+1
                mes='Proof'
                break
            previous_block = block
            block_index += 1
        
        return out, ind, mes