class TestAccountant(unittest.TestCase):
def test initial balance(self):
acc = Accountant()
self.assertEqual(acc.balance, 0)
acc = Accountant(100)
self.assertEqual(acc.balance, 100)
def test_initial_balance(self):
# Default balance should be 0
acc = Accountant()
self.assertEqual(acc.balance, 0)
# Test non-default balance.
acc = Accountant(100)
self.assertEqual(acc.balance, 100)
class TestAccountant(unittest.TestCase):
# a == b or a !=b
# assertEqual(a, b) or assertNotEqual(a, b)
# x is True or x is False
# assertTrue(x) or assertFalse(x)
# veryfity an item is in list or not in list
#assertIn(item, list) or assertNotIn(item, list)
def setUp(self):
self.acc = Accountant()
#default balance shood be 0
def test_initial_balance(self):
self.assertEqual(self.acc.balance, 0)
#non-default balance
acc = Accountant(100)
self.assertEqual(acc.balance, 100)
#test depsit
def test_deposit(self):
self.acc.deposit(100)
self.assertEqual(self.acc.balance, 100)
#test multiple deposit
self.acc.deposit(100)
self.acc.deposit(100)
self.assertEqual(self.acc.balance, 300)
def test_withdrawal(self):
self.acc.deposit(1000)
self.acc.withdraw(100)
self.assertEqual(
self.acc.balance,
900) #if you change 900 to 800 -> AssertionError: 900 != 800
class TestAccount(unittest.TestCase):
"""Test for the class Accountant."""
def setUp(self):
self.acc = Accountant()
def test_initial_balance(self):
# Default balance should be 0.
self.assertEqual(self.acc.balance, 0)
# Test non-default balance.
acc = Accountant(100)
self.assertEqual(acc.balance, 100)
def test_deposit(self):
# Test single deposit.
self.acc.deposit(100)
self.assertEqual(self.acc.balance, 100)
# Test multiple deposits.
self.acc.deposit(100)
self.acc.deposit(100)
self.assertEqual(self.acc.balance, 300)
def test_withdrawal(self):
# Test single withdrawal.
self.acc.deposit(1000)
self.acc.withdraw(100)
self.assertEqual(self.acc.balance, 900)
class MarketPlace:
def __init__(self, robots: ['Robot'], ticker: str):
self.data_provider = DataProvider()
self.robots = robots
self.accountant = Accountant(robots)
self.order_book = OrderBook(ticker)
def training(self, data: 'pd.DataFrame'):
for robot in self.robots:
robot.train(data)
def trading(self):
orders = []
data_from_order_book = self.order_book.get_data()
robots_orders = self.order_book.get_robots_orders()
for robot in self.robots:
data_from_accountant = self.accountant.get_data(robot.username)
robot.update(data_from_order_book, robots_orders[robot.username],
data_from_accountant)
robot.on_tick()
orders += robot.gather_new_orders()
self.order_book.register_orders(orders)
trades = self.order_book.get_last_trades()
self.accountant.register_trades(trades)
def start(self, path: str):
#training_data = self.data_provider.get_training_data()
#self.training(training_data)
self.data_provider.prepare_for_trading(path)
i = 0
total_orders = 0
for orders in self.data_provider:
i += 1
total_orders += len(orders)
#try:
self.order_book.register_orders(orders)
print(i)
print(self.order_book.total_deals)
print(total_orders)
class App(object):
def __init__(self):
self._accountant = Accountant()
def execute(self, change_contract):
staff = self._create_staff_fixtures()
if change_contract:
self._change_contract_for_hourly_to_fixed(staff)
print(self._accountant.calculate_staff_salary(staff))
def _create_staff_fixtures(self):
return Staff([
self._new_employee(150, 'hourly', [5, 5]),
self._new_employee(200, 'hourly', [10, 5, 5]),
self._new_employee(3000, 'fixed', [40, 40, 40, 38]),
self._new_employee(5000, 'fixed', [40, 40, 40, 43]),
self._new_employee(0, 'voluntary', [50, 50, 60, 50]),
])
def _new_employee(self, salary, contract, tracked_hours):
if contract == 'hourly':
cards = self._from_hours_to_cards(tracked_hours)
return Employee(Hourly(salary), HourlyCalculator(), cards)
if contract == 'voluntary':
cards = self._from_hours_to_cards(tracked_hours)
return Employee(Voluntary(), VoluntaryCalculator(), cards)
if contract == 'fixed':
cards = self._from_hours_to_cards(tracked_hours)
return Employee(Fixed(salary), FixedCalculator(), cards)
pass
def _from_hours_to_cards(self, tracked_hours):
cards = []
for hours in tracked_hours:
cards.append(Card(hours))
return cards
def _change_contract_for_hourly_to_fixed(self, staff):
employee = staff.employees()[1] # Getting an hourly
employee.change_contract(Fixed(2500), FixedCalculator())
employee.add_card(Card(10))
class TestAccountant(unittest.TestCase):
def setUp(self):
self.acc = Accountant()
def test_initial_balance(self):
self.assertEqual(self.acc.balance, 0)
acc = Accountant(100)
self.assertEqual(acc.balance, 100)
def test_deposit(self):
self.acc.deposit(100)
self.assertEqual(self.acc.balance, 100)
self.acc.deposit(100)
self.acc.deposit(100)
self.assertEqual(self.acc.balance, 300)
def test_withdrawal(self):
self.acc.deposit(1000)
self.acc.withdraw(100)
self.assertEqual(self.acc.balance, 900)
def main():
# parse arguments
parser = argparse.ArgumentParser()
parser.add_argument('--agent', type=str, default='GAMBLER', help='Which agent to use')
parser.add_argument('--learning_rate', type=float, default=0.1, help='How quickly the algorithm tries to learn')
parser.add_argument('--discount', type=float, default=0.95, help='Discount for estimated future action')
parser.add_argument('--iterations', type=int, default=2000, help='Iteration count')
FLAGS, unparsed = parser.parse_known_args()
# select agent
if FLAGS.agent == 'GAMBLER':
agent = Gambler(learning_rate=FLAGS.learning_rate, discount=FLAGS.discount, iterations=FLAGS.iterations)
elif FLAGS.agent == 'ACCOUNTANT':
agent = Accountant()
elif FLAGS.agent == 'DEEPGAMBLER':
agent = DeepGambler(learning_rate=FLAGS.learning_rate, discount=FLAGS.discount, iterations=FLAGS.iterations)
else:
agent = Drunkard()
# setup simulation
dungeon = DungeonSimulator()
dungeon.reset()
total_reward = 0 # Score keeping
last_total = 0
# main loop
for step in range(FLAGS.iterations):
old_state = dungeon.state # Store current state
action = agent.get_next_action(old_state) # Query agent for the next action
new_state, reward = dungeon.take_action(action) # Take action, get new state and reward
agent.update(old_state, new_state, action, reward) # Let the agent update internals
total_reward += reward # Keep score
if step % 250 == 0: # Print out metadata every 250th iteration
performance = (total_reward - last_total) / 250.0
print(json.dumps({'step': step, 'performance': performance, 'total_reward': total_reward}))
last_total = total_reward
time.sleep(0.0001) # Avoid spamming stdout too fast!
def main():
print("xxx")
parser=argparse.ArgumentParser()
parser.add_argument("--agent", type=str, default = 'DEEPGAMBLER',help="Which agent to use")
parser.add_argument("--learning_agent", type=float, default = 0.1,help="Choose Learning Rate ")
parser.add_argument("--discount", type=float, default = 0.95, help="choose discount")
parser.add_argument("--iterations", type=int, default = 1000,help="No of iterations")
FLAGS,unparsed = parser.parse_known_args()
print("xxx")
if FLAGS.agent == "DRUNKARD":
agent= Drunkard()
elif FLAGS.agent=="ACCOUNTANT":
agent=Accountant()
elif FLAGS.agent == "GAMBLER":
agent=Gambler(FLAGS.learning_agent,FLAGS.discount,1.0,FLAGS.iterations)
else:
agent=DeepGambler(FLAGS.learning_agent,FLAGS.discount,1.0,FLAGS.iterations)
dungeon= DungeonSimulator()
dungeon.reset()
total_reward = 0
print("agent created")
for step in range(FLAGS.iterations):
old_state = dungeon.state
action = agent.get_next_action(old_state)
new_state , reward = dungeon.take_action(action)
agent.update(old_state, new_state, action, reward)
total_reward += reward
if step %250 ==0:
print(json.dumps({'step': step,'total-reward':total_reward, }))
time.sleep(0.0001)
print("FINAL Q TABLE", agent.q_table)
def test_initial_balance(self):
self.assertEqual(self.acc.balance, 0)
#non-default balance
acc = Accountant(100)
self.assertEqual(acc.balance, 100)
def setUp(self):
self.acc = Accountant()
def test_calculates_staff_total_salary(self):
accountant = Accountant()
staff = Mock()
staff.obtain_salary = Mock(return_value=6000)
result = accountant.calculate_staff_salary(staff)
expected = 6000
def __init__(self, robots: ['Robot'], ticker: str):
self.data_provider = DataProvider()
self.robots = robots
self.accountant = Accountant(robots)
self.order_book = OrderBook(ticker)
def __init__(self):
self._accountant = Accountant()
accountant.alpaca_key,
"https://paper-api.alpaca.markets",
api_version="v2",
)
def get_polygon_financial_statement(self, symbol, limit):
params = {}
params["limit"] = limit
financial_statement = self.api.polygon.get(
path="/reference/financials/" + symbol,
params=params,
version="v2")
return financial_statement["results"]
polygon = PolygonInterface(Accountant())
result = polygon.get_polygon_financial_statement("TSLA", 0)
print(result)
# def get_polygon_ticker_symbols(self, pages, perpage=50):
# params = {
# "market": "STOCKS",
# "page": pages,
# # 'perpage': perpage,
# "active": "true",
# }
# data = self.api.polygon.get(
# path="/reference/tickers", params=params, version="v2"
# )
# tickers = data["tickers"]
# return tickers
def __init__(self):
self.accountant = Accountant()
self.polygon = PolygonGateway(self.accountant)
self.investor = Investor()