first

.gitignore

+historical_stock_prices.csv
+historical_stock_prices.csv.zip
+stocks/*

bst.py

+class Node:
+    def __init__(self, key):
+        self.left = None
+        self.right = None
+        self.val = key
+
+# A utility function to insert
+# a new node with the given key
+def insert(root, key):
+    if root is None:
+        return Node(key)
+    else:
+        if root.val == key:
+            return root
+        elif root.val < key:
+            root.right = insert(root.right, key)
+        else:
+            root.left = insert(root.left, key)
+    return root
+
+
+# A utility function to search a given key in BST
+def search(root,key):
+
+    # Base Cases: root is null or key is present at root
+    if root is None:
+        return False
+
+    if root.val == key:
+        return True
+
+    # Key is greater than root's key
+    if root.val < key:
+        return search(root.right,key)
+
+    # Key is smaller than root's key
+    return search(root.left,key)
+
+def inorder(root):
+    if root:
+        list = []
+        list = list + inorder(root.left)
+        list.append(root.val)
+        list = list + inorder(root.right)
+        return list
+    return []

correlation_test.py

+#!/usr/bin/env python3
+
+import csv
+import argparse
+import os
+
+STOCK_FILE_NAME = "historical_stock_prices.csv"
+
+def make_stock_file(stocks, stock):
+    file = open("stocks/" + stock, "w+")
+    writer = csv.writer(file, delimiter=",")
+    writer.writerow(["ticker", "open", "close", "adj_close", "low", "high", "date"])
+    for i in stocks:
+        writer.writerow([i["ticker"], i["open"], i["close"], i["adj_close"], i["low"], i["high"], i["date"]])
+
+
+def get_stocks(file_name, stock):
+      if os.path.isfile("stock/" + stock):
+          file_name = stock
+
+      csvfile = open(file_name)
+
+      reader = csv.DictReader(csvfile)
+      stocks = []
+
+      count = 0
+      for i in reader:
+          if(i["ticker"] == stock):
+              stocks.append(i)
+          count += 1
+
+      if not os.path.isfile(stock):
+          make_stock_file(stocks, stock)
+
+      return stocks
+
+
+def average_gain_after_positive(stocks):
+
+    av_gain = 0
+    count = 0
+
+    for i in range(2, len(stocks)):
+        if float(stocks[i - 1]["open"]) - float(stocks[i - 2]["open"]) > 0:
+            av_gain += float(stocks[i]["open"]) - float(stocks[i - 1]["open"])
+            count += 1
+
+    return av_gain / count
+
+def average_gain_after_turnaround(stocks):
+
+    av_gain = 0
+    count = 0
+
+    for i in range(3, len(stocks)):
+        if float(stocks[i - 1]["open"]) - float(stocks[i - 2]["open"]) > 0 and float(stocks[i - 2]["open"]) - float(stocks[i - 3]["open"]) < 0:
+            av_gain += float(stocks[i]["open"]) - float(stocks[i - 1]["open"])
+            count += 1
+
+    return av_gain / count
+
+
+
+def main(stock):
+    stocks = get_stocks(STOCK_FILE_NAME, stock)
+    print("Average gain after a positive delta: %f" % average_gain_after_positive(stocks))
+    print("Average gain after a turnaround: %f" % average_gain_after_turnaround(stocks))
+    print("Average gain in total: %f" % ((float(stocks[len(stocks) - 1]["open"]) - float(stocks[0]["open"])) / (len(stocks) - 1)))
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--stock", default="random")
+    args = parser.parse_args()
+    main(args.stock)

correlation_test_all.py

+#!/usr/bin/env python3
+
+import csv
+import argparse
+import os
+
+STOCK_FILE_NAME = "historical_stock_prices.csv"
+
+
+LEN_PREV = 3
+
+def main():
+    file = open("all_stocks", "w+")
+    writer = csv.writer(file, delimiter=",")
+    writer.writerow(["ticker", "av_gain_positive", "av_gain_turn", "av_gain"])
+
+    csvfile = open(STOCK_FILE_NAME)
+    reader = csv.DictReader(csvfile)
+    prev_price_dict = {}
+    av_gain_turn_dict = {}
+    count_turn_dict = {}
+    av_gain_pos_dict = {}
+    count_pos_dict = {}
+
+    av_gain_dict = {}
+    count_dict = {}
+
+    for i in reader:
+        
+        if not i["ticker"] in prev_price_dict:
+            prev_price_dict[i["ticker"]] = []
+            av_gain_turn_dict[i["ticker"]] = 0
+            count_turn_dict[i["ticker"]] = 0
+            av_gain_pos_dict[i["ticker"]] = 0
+            count_pos_dict[i["ticker"]] = 0
+            av_gain_dict[i["ticker"]] = 0
+            count_dict[i["ticker"]] = 0
+
+        if len(prev_price_dict[i["ticker"]]) > LEN_PREV and prev_price_dict[i["ticker"]][LEN_PREV - 1] - prev_price_dict[i["ticker"]][LEN_PREV - 2] > 0:
+            av_gain_pos_dict[i["ticker"]] += float(i["open"]) - prev_price_dict[i["ticker"]][LEN_PREV - 1]
+            count_pos_dict[i["ticker"]] += 1
+
+        if len(prev_price_dict[i["ticker"]]) > LEN_PREV and prev_price_dict[i["ticker"]][LEN_PREV - 1] - prev_price_dict[i["ticker"]][LEN_PREV - 2] > 0 and prev_price_dict[i["ticker"]][LEN_PREV - 2] - prev_price_dict[i["ticker"]][LEN_PREV - 3] < 0:
+            av_gain_turn_dict[i["ticker"]] += float(i["open"]) - prev_price_dict[i["ticker"]][LEN_PREV - 1]
+            count_turn_dict[i["ticker"]] += 1
+
+        if len(prev_price_dict[i["ticker"]]) > LEN_PREV and len(prev_price_dict[i["ticker"]]) > 0:
+            av_gain_dict[i["ticker"]] += float(i["open"]) - prev_price_dict[i["ticker"]][LEN_PREV - 1]
+            count_dict[i["ticker"]] += 1
+
+        if len(prev_price_dict[i["ticker"]]) > LEN_PREV:
+            prev_price_dict[i["ticker"]].pop(0)
+        prev_price_dict[i["ticker"]].append(float(i["open"]))
+
+    for i in av_gain_turn_dict:
+        writer.writerow([i, av_gain_pos_dict[i] / count_pos_dict_dict[i], av_gain_turn_dict[i] / count_turn_dict[i], av_gain_dict[i] / count_dict[i]])
+
+
+
+if __name__ == "__main__":
+    main()

random_graph.py

+#!/usr/bin/env python3
+
+import random
+import matplotlib.pyplot as plt
+
+def plot(x, y, stock):
+        plt.clf()
+        _ = plt.plot(x, y)
+        plt.xlabel("Date")
+        plt.ylabel("Price")
+        plt.title("Price of " + stock + " over time")
+        plt.draw()
+
+data = [100]
+x = [1]
+
+for i in range(30):
+    x.append(x[len(x) - 1] + 1)
+    data.append(data[len(data) - 1] + random.randint(-10, 10))
+
+plot(x, data, "AAPL")
+plt.pause(20)

run.py

+#!/usr/bin/env python3
+
+import csv
+import sys
+import matplotlib.pyplot as plt
+import threading
+import time
+import os.path
+import random
+from bst import Node, search, insert, inorder
+import argparse
+
+ACTION_BUY = 1
+ACTION_SELL = 2
+ACTION_STOP = 3
+OUTPUT_NAME = "stocks_list.txt"
+DAYS_AFTER_INITIAL = 60
+
+current_price = 0
+start_price = 0
+
+def str_to_year(str):
+    try:
+        return int(str)
+    except:
+        return -1
+
+def str_year_greater_eq_than(str, year):
+    return int(str.split("-")[0]) >= year
+
+def plot(x, y, stock):
+        plt.clf()
+        _ = plt.plot(x, y)
+        plt.xlabel("Date")
+        plt.ylabel("Price")
+        plt.title("Price of " + stock + " over time")
+        plt.draw()
+
+def str_to_act(str):
+    if str == "b":
+        return ACTION_BUY
+    if str == "s":
+        return ACTION_SELL
+    if str == "x":
+        return ACTION_STOP
+
+class StockSim:
+
+    def random_stock(self):
+        if not os.path.isfile(self.output_name):
+            self.make_stocks_list()
+
+        f = open(self.output_name)
+        num = int(f.readline())
+        rand = random.randint(0, num)
+        i = 0
+        for line in f:
+            if i == rand:
+                return line[:-1]
+            i += 1
+
+    def make_stocks_list(self):
+        csvfile = open(self.file_name   )
+        reader = csv.DictReader(csvfile)
+
+        tree = Node(reader.__next__()["ticker"])
+
+        count = 0
+        for i in reader:
+            if(not search(tree, i["ticker"])):
+                insert(tree, i["ticker"])
+                count += 1
+
+        list = inorder(tree)
+        f = open(self.output_name, "a")
+        f.write(str(count + 1) + "\n")
+        for i in inorder(tree):
+            f.write(i + "\n")
+
+    def get_stocks(self):
+        csvfile = open(self.file_name)
+
+        reader = csv.DictReader(csvfile)
+        self.stocks = []
+
+        count = 0
+        for i in reader:
+            if(count >= DAYS_AFTER_INITIAL and i["ticker"] == self.stock and str_year_greater_eq_than(i["date"], self.year)):
+                self.stocks.append(i)
+            count += 1
+
+    def get_buy_delta(self):
+        min_buy = float(self.stocks[self.current_index]["open"])
+        for i in range(max(self.current_index - self.average_sell_interval, 0),
+                       min(self.current_index + self.average_sell_interval, len(self.stocks))):
+
+            min_buy = min(float(self.stocks[i]["open"]), min_buy)
+        delta = (float(self.stocks[self.current_index]["open"]) - min_buy) / min_buy
+        return delta
+
+    def get_sell_delta(self):
+        max_sell = float(self.stocks[self.current_index]["open"])
+        for i in range(max(self.current_index - self.average_sell_interval, 0),
+                       min(self.current_index + self.average_sell_interval, len(self.stocks))):
+
+            max_sell = max(float(self.stocks[i]["open"]), max_sell)
+        delta = (float(self.stocks[self.current_index]["open"]) - max_sell) / max_sell
+        return delta
+
+    def get_relative_buy_rating(self):
+        rating = self.get_buy_delta()
+        self.buy_rating_sum += rating
+        self.buy_num += 1
+        return self.buy_rating_sum / self.buy_num - rating
+
+    def get_relative_sell_rating(self):
+        rating = self.get_sell_delta()
+        self.sell_rating_sum += rating
+        self.sell_num += 1
+        return self.sell_rating_sum / self.sell_num - rating
+
+    def print_data(self):
+        percent_change = ((float(self.stocks[self.current_index]["open"]) - self.start_price) / self.start_price * 100)
+        print("Stock change over time: %f%%" % percent_change)
+        print("Stock change for time held: %f%%" % (percent_change * self.time_held / self.current_index))
+        print("Money made: %f%%" % (self.money_made / self.start_price * 100))
+
+    def buy_sell_thread(self):
+
+        print("Enter action (b for buy, s for sell, x to quit)")
+
+        i = 0
+        while True:
+            action = str_to_act(input(""))
+            current_price = float(self.stocks[self.current_index]["open"])
+            if action == ACTION_BUY:
+                if self.bought_index == -1:
+                    self.bought_index = self.current_index
+                    print("Bought stock for %f" % current_price)
+                    if self.get_relative_buy_rating() > 0:
+                        print("Good buy!!!!")
+                    else:
+                        print("You suck - bad buy")
+                else:
+                    print("Already have stock - can't buy")
+            elif action == ACTION_SELL:
+                if self.bought_index != -1:
+                    self.money_made += current_price - float(self.stocks[self.bought_index]["open"])
+                    self.time_held += self.current_index - self.bought_index
+                    self.bought_index = -1
+                    print("Sold stock for %f" % current_price)
+                    print("Money made: %f" % self.money_made)
+                    if self.get_relative_sell_rating() > 0:
+                        print("Good sell!!!!")
+                    else:
+                        print("You suck - bad sell")
+                else:
+                    print("Don't have stock - can't sell")
+            elif action == ACTION_STOP:
+                self.print_data()
+                exit()
+            if i % 10 == 1:
+                self.print_data()
+            i += 1
+
+    def run(self, stock="random", year=-1, file_name="historical_stock_prices.csv", plot_size=30):
+
+        self.bought_index = -1
+        self.money_made = 0
+        self.time_held = 0
+        self.average_sell_interval = 5
+        self.buy_num = 0
+        self.sell_num = 0
+        self.buy_rating_sum = 0
+        self.sell_rating_sum = 0
+        self.year = year
+        self.output_name = OUTPUT_NAME
+        self.file_name = file_name
+        self.stock = stock
+        self.current_index = 0
+
+        if stock == "random":
+            self.stock = self.random_stock()
+
+        self.get_stocks()
+        self.start_price = float(self.stocks[0]["open"])
+
+        thread = threading.Thread(target=self.buy_sell_thread)
+        thread.start()
+
+        plt.ion()
+        for i in range(len(self.stocks)):
+
+            self.current_index = i
+            x = []
+            y = []
+            start_loc = max(0, i - plot_size)
+            for j in range(start_loc, i):
+                x.append(self.stocks[j]["date"])
+                y.append(float(self.stocks[j]["open"]))
+
+            plot(x, y, self.stock)
+            plt.pause(1)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--stock", default="random")
+    parser.add_argument("--year", default="-1")
+    args = parser.parse_args()
+    sim = StockSim()
+    sim.run(stock=args.stock, year=str_to_year(args.year))

stock_scrape.py

+from selenium import webdriver
+from datetime import date
+import time
+
+def main(stock):
+    file = open(stock, "a")
+    prev_minute = -1
+
+    while True:
+        now = datetime.now()
+
+        if now.time().minute - prev_minute >= 1 or (prev_minute == 59 and now.time().minute != 59):
+            dt_string = now.strftime("%d/%m/%Y %H:%M")
+            file.write(dt_string + " " + )
+
+        prev_minute = now.time().minute
+
+
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--stock", default="GOOGL")
+    args = parser.parse_args()
+    main(stock)

test.py

+import sys
+import matplotlib.pyplot as plt
+import time
+import numpy as np
+import threading
+
+x = 0
+
+def buy_sell_thread():
+    print(x)
+
+def run():
+    global x
+    x = 1
+    thread = threading.Thread(target=buy_sell_thread)
+    thread.start()
+
+run()