def test_complex_nested_blocks(self):
b = self._build_Model([("if a", FragmentType.IfStatement),
("a body", FragmentType.Body),
("elif b", FragmentType.ElIfStatement),
("b body", FragmentType.Body),
("if aa", FragmentType.IfStatement),
("if aaa", FragmentType.IfStatement),
("aaa body", FragmentType.Body),
("endif aaa", FragmentType.EndIfStatement),
("else", FragmentType.ElseStatement),
("else aa body", FragmentType.Body),
("endif aa", FragmentType.EndIfStatement),
("b body2", FragmentType.Body),
("endif b", FragmentType.EndIfStatement)])
self._check_Model(b, [
Block([
Branch(Fragment(FragmentType.IfStatement, "if a"), ["a body"]),
Branch(Fragment(FragmentType.ElIfStatement, "elif b"), [
"b body",
Block([
Branch(Fragment(FragmentType.IfStatement, "if aa"), [
Block([
Branch(
Fragment(FragmentType.IfStatement,
"if aaa"), ["aaa body"])
], "endif aaa"),
]),
Branch(Fragment(FragmentType.ElseStatement, "else"),
["else aa body"])
], "endif aa"), "b body2"
])
], "endif b")
])
def test_nested_single_if_block(self):
b = self._build_Model([("#if a", FragmentType.IfStatement),
("#if b", FragmentType.IfStatement),
("b body", FragmentType.Body),
("#endif", FragmentType.EndIfStatement),
("#endif", FragmentType.EndIfStatement)])
self._check_Model(b, [
Block([
Branch(Fragment(FragmentType.IfStatement, "#if a"), [
Block([
Branch(Fragment(FragmentType.IfStatement, "#if b"),
["b body"])
], "#endif")
])
], "#endif")
])
def test_single_empty_if_block(self):
b = self._build_Model([("#if a", FragmentType.IfStatement),
("#endif", FragmentType.EndIfStatement)])
self._check_Model(b, [
Block([Branch(Fragment(FragmentType.IfStatement, "#if a"), [])],
"#endif")
])
def __init__(self, id, lastblockAddress, genre, size):
self.id = id
self.blockChain = BlockChain(lastblockAddress)
self.previous_hash = ""
self.genre = genre
self.size = ""
self.newsfiles = []
self.peerIp = []
self.clientIp = []
self.unverifiednews = []
self.vote = {}
self.creatorList = {}
self.castvote = {}
self.BlockStatus = True
self.lastblockAddress = lastblockAddress
#download last block in blockchain
self.userContent = self.blockChain.getUserContent()
self.previousHash = self.blockChain.getBlockHash()
self.block = Block(id, self.previousHash, self.lastblockAddress, genre,
size, self.userContent)
def handle_get_blocks_status(self, request_data):
response = {"profiles": []}
try:
profile = Profile.get(Profile.id == request_data["profileid"])
blocks = Block.select().where((Block.from_profile == profile))
for block in blocks:
status_data = self.get_gp_status(block.to_profile.id)
status_data['profileid'] = block.to_profile.id
response["profiles"].append(status_data)
except (Block.DoesNotExist, Profile.DoesNotExist) as e:
pass
return response
def _build_block(it, if_f):
start_cond = if_f
start_body = list(_build(it))
f = it.current
next_branches = []
while f is not None and f.type != FragmentType.EndIfStatement:
if f.type == FragmentType.Body:
raise SyntaxException()
cond = f
body = list(_build(it))
f = it.current
next_branches.append(Branch(cond, body))
if f is None or f.type != FragmentType.EndIfStatement:
raise SyntaxException()
return Block([Branch(start_cond, start_body)] + next_branches, f.text)
def test_single_if_else_block(self):
b = self._build_Model([("#if a", FragmentType.IfStatement),
("a body", FragmentType.Body),
("#else", FragmentType.ElseStatement),
("else body", FragmentType.Body),
("#endif", FragmentType.EndIfStatement)])
self._check_Model(b, [
Block([
Branch(Fragment(FragmentType.IfStatement, "#if a"),
["a body"]),
Branch(Fragment(FragmentType.ElseStatement, "#else"),
["else body"])
], "#endif")
])
def __init__(self):
'''
Constructor
'''
self.__block_count = 100
self.__hot_space_count = 10
self.__blocks = [] #Blocks
self.__LFiles = [] #Local Files
self.__TFiles = [] #Transparent Filess
#init blocks
for i in range(100):
self.__blocks.append(Block())
def test_single_if_block_with_context(self):
b = self._build_Model([
("before", FragmentType.Body),
("#if a", FragmentType.IfStatement),
("a body", FragmentType.Body),
("#endif", FragmentType.EndIfStatement),
("after", FragmentType.Body),
])
self._check_Model(b, [
"before",
Block([
Branch(Fragment(FragmentType.IfStatement, "#if a"), ["a body"])
], "#endif"), "after"
])
def handle_blocks_search(self, request_data):
response = {"profiles": [], "success": False}
profile_data = request_data["profile"]
if "id" not in profile_data:
return False
profile = Profile.get(Profile.id == profile_data["id"])
buddies = Block.select().where((Block.from_profile == profile))
try:
for buddy in buddies:
model = model_to_dict(buddy)
to_profile = model['to_profile']
del to_profile['user']['password']
response["profiles"].append(to_profile)
response["success"] = True
except (Buddy.DoesNotExist, Profile.DoesNotExist) as e:
pass
return response
def handle_del_block_buddy(self, request_data):
response = {"success": False}
try:
to_profile_model = Profile.get(
(Profile.id == request_data["to_profileid"]))
from_profile_model = Profile.get(
(Profile.id == request_data["from_profileid"]))
count = Block.delete().where(
(Block.from_profile == from_profile_model)
& (Block.to_profile == to_profile_model)).execute()
if count > 0:
publish_data = "\\type\\del_block_buddy\\from_profileid\\{}\\to_profileid\\{}\\".format(
from_profile_model.id, to_profile_model.id)
self.redis_presence_ctx.publish(self.redis_presence_channel,
publish_data)
response["success"] = True
except Profile.DoesNotExist:
pass
return response
def _process_block(b, res, keys):
branches = b.branches
count = len(branches)
last_cond = True
for i in range(0, count):
branch = branches[i]
cond = _patch_cond(branch.condition, keys, last_cond)
if type(cond) is bool:
if i == 0:
if cond:
_process_body(branch.body, res, keys)
else:
res.code_lines += LineCounter.count_body(branch.body)
if count > 1:
next_f = branches[i + 1].condition
next_cond = _patch_cond(next_f, keys, cond)
next_f.type = FragmentType.IfStatement
ConditionAccessor.set_condition(next_f, next_cond)
_process_block(Block(branches[i + 1:], b.end), res, keys)
return
else:
if cond:
res.code_lines += sum([
LineCounter.count_body(b.body)
for b in branches[i + 1:]
])
if branch.condition.type == FragmentType.ElseStatement:
res.text += "#endif\n"
_process_body(branch.body, res, keys)
return
res.text += "#else\n"
_process_body(branch.body, res, keys)
break
else:
res.code_lines = LineCounter.count_body(branch.body)
else:
res.text += branch.condition.text
_process_body(branch.body, res, keys)
last_cond = cond
if type(last_cond) is not bool or count > 1:
res.text += b.end
def handle_block_buddy(self, request_data):
response = {"success": False}
try:
to_profile_model = Profile.get(
(Profile.id == request_data["to_profileid"]))
from_profile_model = Profile.get(
(Profile.id == request_data["from_profileid"]))
success = Block.insert(
to_profile=to_profile_model,
from_profile=from_profile_model).execute() != 0
if success:
publish_data = "\\type\\block_buddy\\from_profileid\\{}\\to_profileid\\{}\\".format(
from_profile_model.id, to_profile_model.id)
self.redis_presence_ctx.publish(self.redis_presence_channel,
publish_data)
response["success"] = True
except Profile.DoesNotExist:
pass
return response
def parseToCFG(self, inputJson):
cfg = CFG()
for block_ in inputJson:
block = Block(block_['blockId'])
for parent in block_['parentBlock']:
block.addParent(parent)
# parse every node individually
for node_ in block_['blocks']:
if self.sandbox:
node_['file'] = "**SandBoxed**"
node = self.parseOp(node_)
if node != None:
block.addNode(node)
if isinstance(node, ParamNode):
cfg.addArgument(node.output)
else:
print "New unseen node: %s" % node_
cfg.addBlock(block)
return cfg
def createNextBlock(preBlock, data):
return Block(preBlock.index + 1, datetime.now(), data, preBlock.hash)
def CreateBlockForPublishing(self):
#Write code for creating a block
if not self.BlockStatus:
return
self.block = Block(self.id, self.previous_hash, self.lastblockAddress,
self.genre, self.size, self.userContent)
newsFileHash = []
fileToHash = {}
self.creatorList = {
self.newsfiles[0]: "QmegEEH5FivGUEUpYMT1kwUqvgGa8dh1ML5NfrtuCbV9QG"
}
for news in self.newsfiles:
print(self.creatorList[news])
newsHash = Ipfs.sendFile(news)
newsFileHash.append(newsHash)
creatorId = self.creatorList[news]
fileToHash[news] = newsHash
self.block.addNews(newsFileHash)
self.block.createNewsMerkleTree(newsFileHash)
#update ContentCreator Rating
UserId = []
UserFileHash = []
for content, creator in self.creatorList.items():
body = self.block.getBody()
data = {}
if creator in body["UserContent"].keys():
userFileHash = body["UserContent"][creator]
# userFileHash=self.block["Body"]["UserContent"][creator]
res = Ipfs.DownloadFile(userFileHash, "user.json")
if res == 1:
f = open("/home/gaurav/NAV-Chain/Miner/userFile.json", "r")
data = json.load(f)
f.close()
else:
data = {
"UserId": creator,
"VotingRating": 0,
"ContentRating": 0,
"ContentList": [content],
"MiningRating": 0,
"UpiId": "",
"BlockList": [],
"NavBirth": ""
}
else:
data = {
"UserId": creator,
"VotingRating": 0,
"ContentRating": 0,
"ContentList": [content],
"MiningRating": 0,
"UpiId": "",
"BlockList": [],
"NavBirth": ""
}
user = User(data["UserId"], data["VotingRating"],
data["ContentRating"], data["ContentList"],
data["MiningRating"], data["UpiId"], data["BlockList"],
data["NavBirth"])
#Calculate contentRating
contentRating = self.block.calculateContentRating(creator)
user.updateContentRating(contentRating)
user.updateContentList(fileToHash[content])
userFile = json.dumps(user.getUser(), indent=4)
f = open("/home/gaurav/NAV-Chain/Miner/userFile.json", "w")
f.write(userFile)
f.close()
UserId.append(creator)
UserFileHash.append(
Ipfs.sendFile("/home/gaurav/NAV-Chain/Miner/userFile.json"))
#Update block list
lastMiner = self.blockChain.getLastMiner()
if lastMiner in body["UserContent"].keys():
lastMinerFileHash = body["UserContent"][lastMiner]
res = Ipfs.DownloadFile(lastMinerFileHash, "LastMiner.json")
if res == 1:
f = open("LastMiner.json", "r")
data = json.load(f)
f.close()
else:
data = {
"UserId": lastMiner,
"VotingRating": 0,
"ContentRating": 0,
"ContentList": [content],
"MiningRating": 0,
"UpiId": "",
"BlockList": [],
"NavBirth": ""
}
user = User(data["UserId"], data["VotingRating"],
data["ContentRating"], data["ContentList"],
data["MiningRating"], data["UpiId"], data["BlockList"],
data["NavBirth"])
user.updateBlockList(self.lastblockAddress)
userFile = json.dumps(user.getUser(), indent=4)
f = open("user.json", "w")
f.write(userFile)
f.close()
UserId.append(creator)
UserFileHash.append(Ipfs.sendFile("user.json"))
# minerFileHash=self.block["Body"]["UserContent"][self.id]
miningRating = 0
if self.id in body["UserContent"].keys():
minerFileHash = body["UserContent"][self.id]
miningRating = self.block.calculateMinerRating()
res = Ipfs.DownloadFile(minerFileHash, "miner.json")
if res == 1:
f = open("miner.json", "r")
data = json.load(f)
f.close()
else:
data = {
"UserId": self.id,
"VotingRating": 0,
"ContentRating": 0,
"ContentList": [],
"MiningRating": 0,
"UpiId": "",
"BlockList": [],
"NavBirth": ""
}
else:
data = {
"UserId": self.id,
"VotingRating": 0,
"ContentRating": 0,
"ContentList": [],
"MiningRating": 0,
"UpiId": "",
"BlockList": [],
"NavBirth": ""
}
user = User(data["UserId"], data["VotingRating"],
data["ContentRating"], data["ContentList"],
data["MiningRating"], data["UpiId"], data["BlockList"],
data["NavBirth"])
user.updateMiningRating(miningRating)
userFile = json.dumps(user.getUser(), indent=4)
f = open("userFile.json", "w")
f.write(userFile)
f.close()
UserId.append(creator)
UserFileHash.append(Ipfs.sendFile("user.json"))
self.block.updateUsers(UserId, UserFileHash)
class Miner:
def __init__(self, id, lastblockAddress, genre, size):
self.id = id
self.blockChain = BlockChain(lastblockAddress)
self.previous_hash = ""
self.genre = genre
self.size = ""
self.newsfiles = []
self.peerIp = []
self.clientIp = []
self.unverifiednews = []
self.vote = {}
self.creatorList = {}
self.castvote = {}
self.BlockStatus = True
self.lastblockAddress = lastblockAddress
#download last block in blockchain
self.userContent = self.blockChain.getUserContent()
self.previousHash = self.blockChain.getBlockHash()
self.block = Block(id, self.previousHash, self.lastblockAddress, genre,
size, self.userContent)
def ReceiveContent(self, miner_id, id, text, genre):
#Code for recieving file from content creator
# if not os.path.exists("NAV/NewsContent"):
# os.mkdir("NAV/NewsContent")
temp = {"miner_id": miner_id, "id": id, "text": text, "genre": genre}
self.unverifiednews.append({
"miner_id": miner_id,
"id": id,
"text": text,
"genre": genre
})
for x in self.peerIp:
if (id == self.id):
#should be done in async fashion
requests.post("{}:80005/getNewsfromPeer".format(x), data=temp)
#Get file from creators and store in this directory
# self.creatorList[fileName]=creatorId
return ""
def ShowContent(self):
return ""
# if os.path.exists("NAV/NewsContent")
# return os.listdir("NAV/NewsContent")
def SelectNews(self, fileName):
#Write code for selecting news
if fileName not in self.newsfiles:
self.newsfiles.append(fileName)
def DeSelectNews(self, fileName):
if fileName in self.newsfiles:
self.newsfiles.remove(fileName)
def sendBlockForVoting(self):
block = {"Miner": self.id, "Files": self.newsfiles}
jsonBlockData = json.dumps(block)
#Send this json file to all miners
def recieveBlockForVoting(self):
if not os.path.exists("NAV/NewsVotingContent"):
os.mkdir("NAV/NewsVotingContent")
#Store file in this directory in json format
pass
def doVoting(self):
fileArray = os.listdir("NAV/NewsVotingContent")
for file in fileArray:
f = open(file, "r")
data = json.load(f)
miner = data["Miner"]
newsfiles = data["Files"]
self.block.updateVote(miner, newsfiles)
self.block.calculateVotingScore()
def requestConsensus(self):
#Generate a random number between 1 and 100000
minerFileHash = self.block["Body"]["UserContent"][self.id]
minerRating = self.blockChain.getMiningRating(minerFileHash)
age == self.blockChain.getMinerAge(minerFileHash)
randomNumber = random.randrange(100000)
data = {
"Miner": self.id,
"MinerRating": minerRating,
"BlockScore": self.block["Header"]["BlockScore"],
"Age": age,
"RandomNumber": randomNumber
}
#Send this data to all random number
def RecieveConsensus(self):
#Recieve json file and store it in a directory ConsensunDirectory
directory = "NAV/ConsensusDirectory"
if not os.path.exists(directory):
os.mkdir(directory)
pass
def consensusAlgorithm(self):
#recieve the data and store in a directory in json form
directory = "NAV/ConsensusDirectory"
fileArray = os.listdir(directory)
totalRequest = 0
scorelist = []
randomNumber = []
for file in fileArray:
totalRequest = totalRequest + 1
f = open(file, "r")
data = json.load(f)
miner = data["Miner"]
score = data["MinerRating"] * (1 -
math.pow(math.e, -1 * data["Age"]))
minerList.append[miner]
scorelist.append[score]
randomNumber.append[data["RandomNumber"]]
mean = randomNumber.mean()
minerList = [x for _, x in sorted(zip(scoreList, minerList))]
randomNumber = [x for _, x in sorted(zip(scoreList, randomNumber))]
score.sort()
start = int(totalRequest * 0.75)
end = totalRequest
minDifference = float('inf')
for i in range(start, end):
diff = math.abs(randomNumber[i] - mean)
if (diff < minDifference):
finalMiner = minerList[i]
if finalMiner.equals(self.id):
self.BlockStatus = True
else:
self.BlockStatus = False
def CreateBlockForPublishing(self):
#Write code for creating a block
if not self.BlockStatus:
return
self.block = Block(self.id, self.previous_hash, self.lastblockAddress,
self.genre, self.size, self.userContent)
newsFileHash = []
fileToHash = {}
self.creatorList = {
self.newsfiles[0]: "QmegEEH5FivGUEUpYMT1kwUqvgGa8dh1ML5NfrtuCbV9QG"
}
for news in self.newsfiles:
print(self.creatorList[news])
newsHash = Ipfs.sendFile(news)
newsFileHash.append(newsHash)
creatorId = self.creatorList[news]
fileToHash[news] = newsHash
self.block.addNews(newsFileHash)
self.block.createNewsMerkleTree(newsFileHash)
#update ContentCreator Rating
UserId = []
UserFileHash = []
for content, creator in self.creatorList.items():
body = self.block.getBody()
data = {}
if creator in body["UserContent"].keys():
userFileHash = body["UserContent"][creator]
# userFileHash=self.block["Body"]["UserContent"][creator]
res = Ipfs.DownloadFile(userFileHash, "user.json")
if res == 1:
f = open("/home/gaurav/NAV-Chain/Miner/userFile.json", "r")
data = json.load(f)
f.close()
else:
data = {
"UserId": creator,
"VotingRating": 0,
"ContentRating": 0,
"ContentList": [content],
"MiningRating": 0,
"UpiId": "",
"BlockList": [],
"NavBirth": ""
}
else:
data = {
"UserId": creator,
"VotingRating": 0,
"ContentRating": 0,
"ContentList": [content],
"MiningRating": 0,
"UpiId": "",
"BlockList": [],
"NavBirth": ""
}
user = User(data["UserId"], data["VotingRating"],
data["ContentRating"], data["ContentList"],
data["MiningRating"], data["UpiId"], data["BlockList"],
data["NavBirth"])
#Calculate contentRating
contentRating = self.block.calculateContentRating(creator)
user.updateContentRating(contentRating)
user.updateContentList(fileToHash[content])
userFile = json.dumps(user.getUser(), indent=4)
f = open("/home/gaurav/NAV-Chain/Miner/userFile.json", "w")
f.write(userFile)
f.close()
UserId.append(creator)
UserFileHash.append(
Ipfs.sendFile("/home/gaurav/NAV-Chain/Miner/userFile.json"))
#Update block list
lastMiner = self.blockChain.getLastMiner()
if lastMiner in body["UserContent"].keys():
lastMinerFileHash = body["UserContent"][lastMiner]
res = Ipfs.DownloadFile(lastMinerFileHash, "LastMiner.json")
if res == 1:
f = open("LastMiner.json", "r")
data = json.load(f)
f.close()
else:
data = {
"UserId": lastMiner,
"VotingRating": 0,
"ContentRating": 0,
"ContentList": [content],
"MiningRating": 0,
"UpiId": "",
"BlockList": [],
"NavBirth": ""
}
user = User(data["UserId"], data["VotingRating"],
data["ContentRating"], data["ContentList"],
data["MiningRating"], data["UpiId"], data["BlockList"],
data["NavBirth"])
user.updateBlockList(self.lastblockAddress)
userFile = json.dumps(user.getUser(), indent=4)
f = open("user.json", "w")
f.write(userFile)
f.close()
UserId.append(creator)
UserFileHash.append(Ipfs.sendFile("user.json"))
# minerFileHash=self.block["Body"]["UserContent"][self.id]
miningRating = 0
if self.id in body["UserContent"].keys():
minerFileHash = body["UserContent"][self.id]
miningRating = self.block.calculateMinerRating()
res = Ipfs.DownloadFile(minerFileHash, "miner.json")
if res == 1:
f = open("miner.json", "r")
data = json.load(f)
f.close()
else:
data = {
"UserId": self.id,
"VotingRating": 0,
"ContentRating": 0,
"ContentList": [],
"MiningRating": 0,
"UpiId": "",
"BlockList": [],
"NavBirth": ""
}
else:
data = {
"UserId": self.id,
"VotingRating": 0,
"ContentRating": 0,
"ContentList": [],
"MiningRating": 0,
"UpiId": "",
"BlockList": [],
"NavBirth": ""
}
user = User(data["UserId"], data["VotingRating"],
data["ContentRating"], data["ContentList"],
data["MiningRating"], data["UpiId"], data["BlockList"],
data["NavBirth"])
user.updateMiningRating(miningRating)
userFile = json.dumps(user.getUser(), indent=4)
f = open("userFile.json", "w")
f.write(userFile)
f.close()
UserId.append(creator)
UserFileHash.append(Ipfs.sendFile("user.json"))
self.block.updateUsers(UserId, UserFileHash)
def publishBlock(self):
blockFile = json.dumps(self.block.getBlock(), indent=4)
blockFileName = "block_next_to_" + self.lastblockAddress + ".json"
f = open(blockFileName, "w")
f.write(blockFile)
f.close()
blockAddress = Ipfs.sendFile(blockFileName)
#Send this blockaddress to all peers
return blockAddress
def resetMiningProcess(self):
self.previous_hash = ""
self.genre = ""
self.size = ""
self.newsfiles = []
self.block = Block.Block(id, "", "", "", 0, {})
def resetMiningProcess(self):
self.previous_hash = ""
self.genre = ""
self.size = ""
self.newsfiles = []
self.block = Block.Block(id, "", "", "", 0, {})
import pygame
from Model.Block import Block
from Model.Ball import Ball
from Model.Computer import Computer
from constants import SCREEN_WIDTH
Player1 = Block(20, 200, "Player1")
Player2 = Block(SCREEN_WIDTH - 30, 200, "Player2")
Ball = Ball(390, 290, 20)
Computer = Computer(Player1, Player2, Ball)
block_list = pygame.sprite.Group()
ball_list = pygame.sprite.Group()
block_list.add(Player1)
block_list.add(Player2)
ball_list.add(Ball)
play = False
game_mode = ""
is_running = True
def set_default():
Player1.reset()
Player2.reset()
Ball.reload()
def createGenesisBlock():
data = BlockData(1, [{'fromMiner': '', 'toMiner': '', 'amount': '0'}])
return Block(0, datetime.now(), data, '0')
