def main():
a1 = Account() #Creates an account with default values
acc = Account(1122, 20000, 0.045)
acc.withdraw(2500)
acc.deposit(3000)
print(acc.getAccountID(), acc.getBalance(), acc.getMonthlyInterestRate(),
acc.getMonthlyInterest())
def selectAccount(self):
flag = 0
with open('accounts.txt') as f:
lines = f.readlines()
for line in lines:
data = line.split(" // ")
a = Account(str(data[0]), str(data[1]))
if len(self.accounts) == 0:
self.accounts.append(a)
print("Account selected: " + data[0])
flag = 1
break
else:
flagC = 0
for account in self.accounts:
if a.username == account.username:
flagC = 1
if flagC == 0:
self.accounts.append(a)
print("Account selected: " + data[0])
flag = 1
break
if flag == 1:
return a
else:
return Account("", "")
def initial_accounts(scenario, outline):
acc1 = Account('1', 0)
acc2 = Account('2', 150)
accounts_dict = {}
accounts_dict[acc1.id] = acc1
accounts_dict[acc2.id] = acc2
world.accounts = accounts_dict
world.deposit_to = accounts_dict
def initial_accounts(scenario,outline):
acc1 = Account('1', 0)
acc2 = Account('2', 150)
accounts_dict = {}
accounts_dict[acc1.id] = acc1
accounts_dict[acc2.id] = acc2
world.accounts=accounts_dict
world.withdrawal_from = accounts_dict
def test_init(self):
with self.assertRaises(TypeError):
Account('100.0')
with self.assertRaises(ValueError):
Account(-100.0)
account = Account()
self.assertEqual(account.balance, 0.0)
def test_decimals(self):
# Long with decimals
a = Account(2)
a.EnterPosition('Long', 1, 0.00000001)
self.assertEqual(a.TotalValue(0.00000002), 3)
a.ClosePosition(a.Positions[0], 1, 0.00000002)
self.assertEqual(a.BuyingPower, 3)
#Short with decimals
a = Account(2)
a.EnterPosition('Short', 1, 0.00000002)
self.assertEqual(a.TotalValue(0.00000001), 2.5)
a.ClosePosition(a.Positions[0], 1, 0.00000001)
self.assertEqual(a.BuyingPower, 2.5)
def load_test_user(self):
"""
Test function that auto-generate accounts and appended to the account list.
"""
bank = Bank("RBC", 5000)
bank2 = Bank("RBC", 5000)
bank3 = Bank("RBC", 5000)
user1 = User("Saida", 20)
user2 = User("Andrew", 20)
user3 = User("Scott", 20)
self._accounts.append(Account(bank3, user3))
self._accounts.append(Account(bank2, user2))
self._accounts.append(Account(bank, user1))
def test_isOwner(self):
#boundary - is owner
acc = Account(1, 10, 1234)
owner = acc.getOwner()
self.assertEqual(owner, '1234')
#boundary - not owner
acc = Account(1, 10, 1234)
swner = acc.getOwner()
self.assertNotEqual(owner, '12345')
#boundary - not owner
acc = Account(1, 10, 1234)
owner = acc.getOwner()
self.assertNotEqual(owner, 'abc')
def __init__(self, master):
super().__init__(master)
self.master = master
self.user = User()
self.account = Account()
self.master.geometry("500x500")
self.master.title("Most Secure banking")
self.master.geometry("500x500")
self.master.config(bg='orange')
# pages
self.entry_page = Frame(self.master)
self.user_create_page = Frame(self.master)
self.user_logged_page = Frame(self.master)
self.user_login_page = Frame(self.master)
self.user_deposit_page = Frame(self.master)
self.user_withdraw_page = Frame(self.master)
self.user_edit_page = Frame(self.master)
self.user_delete_page = Frame(self.master)
self.user_send_page = Frame(self.master)
self.user_overview_page = Frame(self.master)
self.UI_elements()
self.create_entry_page()
self.open_windows = []
def mosaicClick(self):
c = NemConnect(self.host.get(), int(self.port.get()))
privkey = self.privKeyEntry.get()
fqn = self.create_namespaceNameEntry.get(
) + '.' + self.create_mosaicNameEntry.get()
desc = self.mosaicDescText.get("1.0", END)
defaultProps = {
'divisibility': int(self.m_d.get()),
'initialSupply': int(self.m_is.get()),
'supplyMutable': True if self.m_ms.get() else False,
'transferable': True if self.m_t.get() else False
}
multisig = self.multisigPubKeyEntry.get() if self.multisigEnabled.get(
) else None
if self.m_hasLevy.get():
defaultProps['levy'] = {
"type":
int(self.m_levy_type.get()),
"recipient":
self.m_levy_recipient.get(),
"mosaicFqn":
self.m_levy_namespace.get() + '.' + self.m_levy_mosaic.get(),
"fee":
int(self.m_levy_fee.get())
}
try:
a = Account(privkey)
ok, j = c.prepareMosaicCreation(a.getHexPublicKey(), multisig, fqn,
desc, defaultProps)
self.commonHandle(c, a, ok, j)
except Exception as e:
self.report(str(e), traceback.format_exc())
def createAccount(self,accountNo,custName,balance):
self.account=Account()
self.account.setAccountNo(accountNo)
self.account.setCustName(custName)
self.account.setBalance(balance)
self.accounts.update({accountNo:self.account})
print "Account has been successfully created for account number",accountNo
def build_complete_binary_tree(self, depth):
# Build the complete binary tree structure
super().build_complete_binary_tree(depth)
# Construct Account objects
accounts_per_shard = 10
num_shards = (2**(depth + 1) - 1)
num_accounts = accounts_per_shard * num_shards
linked_accounts_per_account = 2
self.accounts = [
Account(id=x,
gas_size=random.randint(1, 20),
storage_size=random.randint(1, 100))
for x in range(num_accounts)
]
for account in self.accounts:
possible_linked_accounts = self.accounts.copy()
possible_linked_accounts.remove(account)
account.linked_accounts = list(
np.random.choice(possible_linked_accounts,
size=linked_accounts_per_account,
replace=False))
for linked_account in account.linked_accounts:
account.linked_accounts_tx_count[
linked_account] = random.randint(1, 3)
# Assign accounts to shards
accounts_list = self.accounts.copy()
np.random.shuffle(accounts_list)
for shard in self.shards:
shard.load = accounts_list[:accounts_per_shard]
accounts_list = accounts_list[accounts_per_shard:]
self.account_shard_map = self.build_account_shard_map()
self.edge_weights_map = self.calculate_edge_weights()
def main():
# Create ten accounts
accounts = [Account(i, 100) for i in range(10)]
while True:
# Prompt the user to enter an id
ID = eval(input('Enter an account id: '))
while ID > 9 and ID < 0:
ID = eval(input('Incorrect id, enter again!: '))
account = accounts[ID]
print('Main Menu')
print('1: Check Balance\n2: Withdraw\n3: Deposit\n4: Exit')
choice = eval(input('Enter a choice: '))
while choice != 4:
if choice == 1:
print('The balance is ', account.getBalance())
elif choice == 2:
withdrawAmount = eval(input('Enter an amount to withdraw: '))
account.withdraw(withdrawAmount)
elif choice == 3:
depositAmount = eval(input('Enter an amount to deposit: '))
account.deposit(depositAmount)
else:
break
print('Main Menu')
print('1: Check Balance\n2: Withdraw\n3: Deposit\n4: Exit')
choice = eval(input('Enter a choice: '))
def create_account(self, username, password, first_name, last_name,
address):
"""
Creates a bank account for the user
:param username: username
:param password: password
:param first_name: first name
:param last_name: last name
:param address: home address
:return: Tuple that contains boolean variable that determines if account creation is
successful or not and a message
"""
# Check if the username does not exist
if not username in self.account_data:
next_account_id = len(self.account_data.keys()) + 1
# If the account doesn't exist, then we can create a bank account with this username
self.account_data[username] = Account(next_account_id, username,
password, first_name,
last_name, address)
return (True, "Account has been successfully created")
# Username already exists. User must enter a different username
return (False,
"Username already exists. Please enter a different username.")
def register():
with sqlite3.connect("data/database.db") as database:
response = {}
cursor = database.cursor()
session.clear()
if (request.is_json):
content = request.get_json()
if ("username" in content and "password" in content
and "contact" in content):
account = Account(name=content["username"],
contact=content["contact"])
if (register_account(cursor, account, content["password"])):
response["status"] = "success"
else:
response["status"] = "error"
response["reason"] = "registeration failed"
else:
response["status"] = "error"
response["reason"] = "missing username or password"
else:
response["status"] = "error"
response["reason"] = "Invalid JSON"
database.commit()
cursor.close()
return json.dumps(response)
def __init__(self):
self.user = User()
self.account = Account()
self.employee = Employee()
self.service = Service()
self.utilities = Utilities()
self.initAmt = 0
def transactionCodeChooser(self, lineData):
transactionCode = lineData[self.transactionIdx]
accountTo = lineData[self.accountToIdx]
accountFrom = lineData[self.accountFromIdx]
amount = lineData[self.amountDataIdx]
name = lineData[self.nameDataIdx]
if self.accountDict.has_key(accountTo):
if transactionCode == "DL":
if self.accountDict[accountTo].canDeleteAccount(name):
del self.accountDict[accountTo]
else:
print "Incorrect name or account does not exist"
elif transactionCode == "TR":
if self.accountDict.has_key(accountFrom):
if not self.accountDict[accountTo].transfer(
amount, self.accountDict[accountFrom]):
print "Error Transferring"
else:
print "Error Transferring"
elif transactionCode == "WD":
if not self.accountDict[accountTo].withdrawMoney(amount):
print "Withdraw error"
elif transactionCode == "DE":
if not self.accountDict[accountTo].depositMoney(amount):
print "Deposit error"
else:
if transactionCode == "CR":
wasCreated = Account(accountTo, amount, name,
self.accountDict).isCreated
def verifySign(line):
""": ([a-f0-9]+) : ([a-f0-9]+) : ([a-f0-9]+) : ([0-9]{2}) : ([a-f0-9]+)$"""
f = inspect.currentframe()
rematch = f.f_back.f_globals[f.f_code.co_name].__doc__
res = re.match(rematch, line)
if not res:
return False
privateKeyHex = res.group(1)
expectedPublic = unhexlify(res.group(2))
expectedSignature = unhexlify(res.group(3))
dataLength = int(res.group(4))
data = unhexlify(res.group(5))
assert (len(data) == dataLength)
account = Account(privateKeyHex)
if account.pk == expectedPublic:
computedSignature = account.sign(data)
if computedSignature == expectedSignature:
return True
else:
print('Failed when calculating signature:')
print(' computed signature:' + hexlify(computedSignature))
print(' expected signature:' + hexlify(expectedSignature))
return False
else:
print('Failed public from private:')
print(' computed public:' + hexlify(account.pk))
print(' expected public:' + hexlify(expectedPublic))
return False
def pressedSettings(self, event):
sender = self.sender()
id = 0
for bid, btn in self.buttonsMap.items():
if btn == sender:
id = bid
try:
current_account_id, current_account_login, current_account_password, current_account_status = \
self.getRowInformation(id)
except:
sender.setStyleSheet("background-color: #FF0000")
return
sender.setStyleSheet("background-color: #E1E1E1")
user = None
if not id in users:
user = Account(current_account_id, current_account_login,
current_account_password, current_account_status,
True, 0, 0, 0, 0)
users[id] = user
else:
user = users[id]
user.login = current_account_login
user.password = current_account_password
self.createSettingsForAccountWindow(user)
def verifyKey(line):
"""^: ([a-f0-9]+) : ([a-f0-9]+) : ([a-f0-9]+) : ([A-Z2-7]+)$"""
f = inspect.currentframe()
rematch = f.f_back.f_globals[f.f_code.co_name].__doc__
res = re.match(rematch, line)
if not res:
return False
privateKeyHex = res.group(1)
expectedPublic = unhexlify(res.group(3))
expectedAddress = res.group(4)
account = Account(privateKeyHex)
if account.pk == expectedPublic:
if account.address == expectedAddress:
return True
else:
print('Failed when calculating address:')
print(' computed address:' + account.address)
print(' expected address:' + expectedAddress)
return False
else:
print('Failed public from private:')
print(' computed public:' + hexlify(accountp.pk))
print(' expected public:' + hexlify(expectedPublic))
return False
def Start(self, InitialCapital, Logic, Lookback=1, Start=False, End=False):
# Initialize account
self.Account = Account(InitialCapital)
# Adjust custom timeframe
if not (Start): Start = self.Data['date'].iloc[0]
if not (End): End = self.Data['date'].iloc[-1]
self.Start, self.End = Start, End
self.Timeframe = self.Data.loc[(self.Data['date'] >= Start)
& (self.Data['date'] <= End)]
# Enter backtest ---------------------------------------------
for Index, Today in self.Timeframe.iterrows():
Days = [self.Data.loc[Index]]
for Day in range(Lookback):
try:
Days.insert(1, self.Data.loc[Index - Day - 1])
except KeyError:
pass
try:
Days.insert(1, self.Data.loc[Index + 1])
except KeyError:
pass
# Update account variables
self.Account.Date = Today['date']
self.Account.Equity.append(self.Account.TotalValue(Today['open']))
# Execute trading logic
Logic(self.Account, Period(Days))
# Cleanup empty positions
self.Account.PurgePositions()
def create_account():
print("Choice number 1 is selected by the customer\n")
if len(set_of_accounts) < 10:
name = str(input("Input Fullname : "))
pin = str(input("Please input a pin of your choice : "))
balance = eval(
input("Please input a amount to deposit to start an account : "))
account = Account(name, pin, balance)
set_of_accounts.add(account)
print("\n----New account created successfully !----")
print("Note! Please remember the Name and Pin")
print("========================================")
else:
print(
"\nCustomer registration exceed reached the no:of spaces left are: "
+ str((len(set_of_accounts)) - 10))
# This statement below helps the user to go back to the start of the program (main menu).
input(
"Please press enter key to go back to main menu to perform another function or exit ..."
)
def create_account():
print("Choice number 1 is selected by the customer\n")
# creates new accounts with the attributes limit to 9 accounts to keep project small
if len(set_of_accounts) < 10:
nric = check_NRIC_not_repeated()
name = str(input("Input Fullname : "))
pin = str(input("Please input a pin of your choice : "))
balance = check_balance_valid(
"Please input a amount to deposit to start an account: ")
#create Account object and add the set_of_accounts
account = Account(nric, name, pin, balance)
set_of_accounts.add(account)
print("\n----New account created successfully !----")
print("Note! Please remember the Name and Pin")
print("========================================")
else:
print(
"\nCustomer registration exceed reached the no:of spaces left are: "
+ str((len(set_of_accounts)) - 10))
# This statement below helps the user to go back to the start of the program (main menu).
input(
"Please press enter key to go back to main menu to perform another function or exit ..."
)
def opt_wrapper(params):
"""
optimizing for periods
"""
# assign parameters
periods_bol = int(params[0]) # space from optimizer returns floats
periods_adx = int(params[1])
periods_rsi = int(params[2])
adx_value = int(params[3])
###### Define Simulations ######
data = Data(start_date="20-03-01") # historical data interfal: hours
df = data.load()
strategy = Strategy(df=df,
periods_bol=periods_bol,
periods_adx=periods_adx,
periods_rsi=periods_rsi,
adx_value=adx_value)
account = Account(balance={"euro": 1000, "btc": 0}, av_balance=0.8)
sim = Sim(strategy=strategy,
account=account,
stake_amount=50,
stop_loss=0.02)
sim_result = sim.start()
# negate as optimization looks for a minimum
sim_result = -sim_result["account"].balance["euro"]
return sim_result
def showMenu(self):
print("************Welcome to Account Bank**************")
action = self.getUserOption()
if action == 1:
print(self.currentAccount.showBalance())
self.loading('self.loading')
self.showMenu()
elif action == 2:
value = self.tryParseInt("How much do you want to withdraw? ")
self.currentAccount.withdrown(value)
self.loading('withdrawing')
self.showMenu()
elif action == 3:
value = self.tryParseInt("How much do you want to deposit? ")
self.currentAccount.deposit(value)
self.loading('depositing')
self.showMenu()
elif action == 4:
newAccountID = input(
"Type the accountID do you want to transfer to?")
newAccount = Account(newAccountID)
value = self.tryParseInt("How much do you want to transfer? ")
self.currentAccount.transfer(newAccount, value)
self.loading('transfering')
self.showMenu()
elif action == 5:
self.loading('exiting')
sys.exit()
else:
self.showMenu()
def transferClick(self):
try:
c = NemConnect(self.host.get(), int(self.port.get()))
privkey = self.privKeyEntry.get()
multisig = self.multisigPubKeyEntry.get(
) if self.multisigEnabled.get() else None
recipient = self.transferRecipient.get()
amount = int(self.transferAmount.get())
message = self.transferMessage.get("1.0", END)
mosaics = map(
lambda x:
(x['t'].get() + '.' + x['m'].get(), int(x['q'].get())),
self.attachments)
if len(self.attachments) > 0:
amount *= 1000000
a = Account(privkey)
ok, j = c.prepareTransfer(a.getHexPublicKey(), multisig, recipient,
amount, message, mosaics)
self.commonHandle(c, a, ok, j)
except Exception as e:
self.report(str(e), traceback.format_exc())
def run():
logging.basicConfig(filename='log.txt',
filemode='a',
format='%(asctime)s,%(msecs)d %(name)s %(levelname)s %(message)s',
datefmt='%d-%b-%y %H:%M:%S',
level=logging.DEBUG)
logging.info('Initiating Run')
auth_client = Account()
history = History('BTC-USD')
sma50 = history.sma(50)
sma100 = history.sma(100)
if sma50 > sma100:
bull_flag = True
else:
bull_flag = False
while True:
if datetime.now().minute == 0:
history = History('BTC-USD')
if bull_flag is False and history.sma(50) > history.sma(100):
buy = auth_client.buy('BTC-USD')
logging.info(f'Golden Cross: {buy}')
bull_flag = True
if bull_flag is True and history.sma(50) < history.sma(100):
sell = auth_client.sell('BTC-USD')
logging.info(f'Death Cross: {sell}')
bull_flag = False
else:
logging.info('No Crossover event')
time.sleep((60 * 60) - datetime.now().minute * 60 - (datetime.now().microsecond / 1000000))
else:
time.sleep((60 * 60) - datetime.now().minute * 60 - (datetime.now().microsecond / 1000000))
def go_to_option(self,option):
if option==1:
Account().display_closed_accounts_history()
if option==2:
print("Successfully logged out")
else:
self.show_menu()
def __init__(self, btcTrader, apiName, authId, authPass):
Engine.__init__(self, apiName, btcTrader, 1) # refresh rate of 1 second. In the futur with the websockets we will probably put 0 and use some kind of select
self.req = self.CreateRequester(authId, authPass)
self.depth = {}
self.clock = Clock()
self.first = 1
self.account = Account()
def load():
if os.path.isfile('data/accounts.csv'):
path = 'data/accounts.csv'
else:
path = 'data/FakeNameSet20.csv'
with open(path, mode='r') as csv_file:
csv_reader = csv.reader(csv_file)
line_count = 0
for row in csv_reader:
if line_count == 0:
print(f'Column names are {", ".join(row)}')
line_count += 1
else:
accounts.append(
Account(row[0], row[1], row[2], row[3], row[4], row[5],
row[6], row[7], row[8], row[9], row[10]))
line_count += 1
csv_file.close()
if os.path.isfile('data/books.json'):
path = 'data/books.json'
else:
path = 'data/booksset1.json'
js_books = json.load(open(path, 'r'))
for js_book in js_books:
book = Book(js_book['author'], js_book['country'],
js_book['image_link'], js_book['language'],
js_book['link'], js_book['pages'], js_book['title'],
js_book['year'])
books.append(book)
