Ejemplo n.º 1
0
def parseCap(code):
    url = "http://www.sse.com.cn/sseportal/webapp/datapresent/querythismyquat?productId=" + code + "&prodType=1"
    from lxml import etree
    from lxml.html import parse

    page = parse(url).getroot()
    # result = etree.tostring(page)
    # print result
    r = page.xpath("//strong")
    # print len(r)
    from stock import Stock

    stock = Stock(code)
    cap = []
    for data in r:
        dataTree = etree.ElementTree(data)
        # print etree.tostring(dataTree)
        values = dataTree.xpath("//text()")
        temp = values[0].strip()
        # print temp
        cap.append(temp)
    # print cap
    stock.totalCap = float(cap[0])
    stock.floatingCap = float(cap[1])
    # print stock
    return stock
Ejemplo n.º 2
0
	def get(self):
		s = Stock()
		_d = s.iterDump()
		for line in _d:
			self.write(str(line))
			self.write("\n")
		s.Close()
Ejemplo n.º 3
0
	def get(self):
		try:
			s = Stock()
			reply = ""
			#Check for price/quantity
			price = self.get_argument('price','')
			quantity = self.get_argument('quantity','')
			value = self.get_argument('value','')
			if(price=='true'):
				#Get the egg unit price
				price = s.getItemPrice('egg')
				reply += "egg unit price: " + str(price)
			if(quantity=='true'):
				quantity = s.getItemQuantity('egg')
				reply += "egg stock level: " + str(quantity)
			if(value=='true'):
				#Get item total value
				total = s.getItemTotal('egg')
				reply += "egg total stock value: " + str(total)
			if(reply==""):
				reply = "OK"
			self.write(reply)
			s.Close()
		except Exception as e:
			print(e)
Ejemplo n.º 4
0
def create_stock(quote, max_iterations, start, end, stocks, index):
    '''
    Create a stock from a quote
    '''
    if (quote['StockExchange'] == None):
        return
    success = False
    for i in range(max_iterations):
        if not success:
            url = historical_url(quote['symbol'], start, end)
            data = request_json(url)

            if 'error' in data and i == (max_iterations-1):
                raise Exception('Error in call to historical api',
                                data)
            elif 'error' not in data:
                success = True

    quotes = data['query']['results']['quote']
    close_prices = [float(q['Close']) for q in quotes]
    stock = Stock(quote, close_prices)
    stock.index = index
    lock.acquire()
    stocks.append(stock)
    lock.release()
Ejemplo n.º 5
0
    def download_sp500_stock_info(self):

        stock_list = []

        request = urllib2.Request(self.sp500_stock_url)
        request.add_header("User-Agent",
                           "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.116 Safari/537.36")
        response = urllib2.urlopen(request)
        resp_soup = BeautifulSoup(response.read(), 'html.parser')
        table_tag = resp_soup.find("table")
        table_soup = BeautifulSoup(str(table_tag).replace("\n", ""), 'html.parser')
        tr_tag_list = table_soup.find_all("tr")
        row_index = 0
        for tr_tag in tr_tag_list:
            if row_index != 0:
                tr_tag_soup = BeautifulSoup(str(tr_tag), "html.parser")
                td_tag_list = tr_tag_soup.find_all("td")
                stock = Stock()
                stock.symbol = td_tag_list[0].string
                stock.name = td_tag_list[1].string
                stock.sector = td_tag_list[3].string
                stock.industry = td_tag_list[4].string
                stock_list.append(stock)

            row_index += 1
        return stock_list
Ejemplo n.º 6
0
def parseCap(code):
    url = "http://www.sse.com.cn/sseportal/ps/zhs/hqjt/hqjy.shtml"
    from lxml import etree
    from lxml.html import parse

    page = parse(url).getroot()
    result = etree.tostring(page)
    print result
    r = page.xpath("//strong")
    # print len(r)
    from stock import Stock

    stock = Stock(code)
    cap = []
    for data in r:
        dataTree = etree.ElementTree(data)
        # print etree.tostring(dataTree)
        values = dataTree.xpath("//text()")
        temp = values[0].strip()
        # print temp
        cap.append(temp)
    # print cap
    stock.totalCap = float(cap[0])
    stock.floatingCap = float(cap[1])
    # print stock
    return stock
Ejemplo n.º 7
0
def main():
  s = Stock()
  memory = Queue(maxsize=ma_days)
  ma_arr = []
  populate_mem(memory, s)
  #populate the moving avg array with the first one
  ma_arr.append(s.get_ma())

  for x in range(1,sim_len,1):
    populate_ma(ma_arr, memory, s)
  map(print_ma, ma_arr)
Ejemplo n.º 8
0
def main():
  output.print_header()
  with io.open(Config.SAMPLE_INFILE, buffering=Config.BUFFER_SIZE) as infile:
    stock = None
    for line in infile:
      row = Row(csv.reader([line]).next())
      if row.permno.isdigit():
        if not stock or not stock.same_stock(row):
          if stock:
            stock.done()
          stock = Stock(row)
        else:
          stock.next_row(row)
    stock.done()
Ejemplo n.º 9
0
def parseFinanceData(code):
    from lxml import etree
    from lxml.html import parse
    url = 'http://www.windin.com/home/stock/stock-div/600309.SH.shtml'
    #print url
    page = parse(url).getroot()
    result = etree.tostring(page)
    print result
    import io
    with io.open('test.xml','wb') as f:
       #f.writelines(result)
       pass 
    
    r = page.xpath('//div[@class="tab01"]');
    #print len(r)    
    from stock import Stock
    stock = Stock(code)
    for a in r:  
        tree= etree.ElementTree(a)  
        #print etree.tostring(tree) 
        datas = tree.xpath('//td') 
        #print len(datas)
        index =0
        for data in datas:
            dataTree = etree.ElementTree(data);
            #print etree.tostring(dataTree)
            values = dataTree.xpath('//text()')
            index +=1
            #print index
            if (len(values)==1 ):
                #print values
                #print len(values[0])
                #print str(values[0])
                if (index == 32):
                    mgsy = values[0]
                    #print mgsy+'***************'
                    stock.mgsy = mgsy
                elif (index == 52):
                    mgjzc = values[0]
                    #print mgjzc+'***************'
                    stock.mgjzc = mgjzc
                elif (index == 2):
                    last_update = values[0]
                    #print last_update
                    stock.lastUpdate = last_update                    
         
        return stock  
Ejemplo n.º 10
0
	def __init__(self):
		self.stock = Stock()
		#self.workers = Gegevensstruct("hashmap")
		self.workers = Stack()
		self.worker_list = Gegevensstruct("hashmap")
		self.orders = Queue(50)
		self.orders_busy = Gegevensstruct("hashmap")
		self.users = Gegevensstruct("hashmap")
Ejemplo n.º 11
0
	def addStock(self, event = None):
		#Check for nothing or spaces
		if self.entry.get().strip() == "":
			messagebox.showwarning("No Entry", "Enter a valid stock ticker symbol")
			self.entry.delete(0, END)
		else:
			#Make the API request and save the response
			company = self.entry.get().strip().upper()
			query1 = "http://finance.yahoo.com/d/quotes.csv?s="
			query2 = "&f=nl1c1p2"
			response = urllib.request.urlopen(query1 + company + query2)
			data = response.read()
			text = data.decode()

			#Invalid case
			if "N/A" in text:
				messagebox.showerror("Invalid Entry", "This stock does not exist" \
					+ " or data could not be pulled for it.")
			#Valid case
			else:	
				#Create a new stock object with the raw parameters for processing
				newStock = Stock(company, text)

				#Check if stock is already in portfolio, else --> add it
				for s in self.myPortfolio:
					if s.getTicker() == newStock.getTicker():
						messagebox.showwarning("Repeated Entry", "This stock is" \
							+ " already in your portfolio")
						self.resetEntry(None)
						return
				self.myPortfolio.append(newStock)
				toDisplay = newStock.stringify()
				
				#Add to portfolio and determine color (gain/loss)
				self.portfolio.insert(END, toDisplay[0])
				self.portfolio.see(END)
				if toDisplay[1] == "gain":
					self.portfolio.itemconfig(END, fg=self.money, selectbackground="green")
				elif toDisplay[1] == "loss":
					self.portfolio.itemconfig(END, fg="red", selectbackground="red")
				else:
					self.portfolio.itemconfig(END, fg="#B2B200", selectbackground="yellow")

		#Clear the entry field regardless
		self.resetEntry(None)
Ejemplo n.º 12
0
def main():
	stock_names = ['ba', 'cat', 'dd', 'ge', 'gs', 'ibm', 'jnj', 'jpm', 'mmm', 'xom']
	#for stock in stocks:
	#   print(stock)
    
        # Andy's comment 2

        # andy's comment

	Stocks = []
	for stock in stock_names:
	    this_stock = Stock(stock, '../data')
	    this_stock.populate()
	    Stocks.append(this_stock)

	trainingData = learningData()
	trainingData.construct(Stocks,['1/1/1980', [50, 100, 150], 50])
	trainingData.append(Stocks,['1/1/1982', [50, 100, 150], 50])
	
	cv_data = learningData()
	cv_data.construct(Stocks,['1/1/1990', [50, 100, 150], 50])
	cv_data.append(Stocks,['1/1/1992', [50, 100, 150], 50])
	
	clf = linear_model.Ridge (alpha = 0.1, fit_intercept=False)
	clf.fit(trainingData.X, trainingData.y)
	

    # To look for overfitting the code loops through values of alpha plotting distance between
    # the predicted values and actual data and various alphas
	alph = 0.01
	f = open('alpha.txt', 'w')
	while alph < 0.2:
		# First fit the data for each alpha
	    clf = linear_model.Ridge (alpha = alph, fit_intercept=False)
	    clf.fit(trainingData.X, trainingData.y)
	    # Now measure how close model comes for both training data and cross validation data
	    # The clf.predict produces a vector with one element for each element in the sample
	    predict_data = clf.predict(trainingData.X)
	    predict_cv = clf.predict(cv_data.X)
	    # The linagl function in np takes a L2 norm of the difference
	    diff_data = (1.0/trainingData.m) * np.linalg.norm(predict_data - trainingData.y)
	    diff_cv = (1.0/cv_data.m) * np.linalg.norm(predict_cv - cv_data.y)
	    # Write out the values
	    f.write(str(alph) +  " " + str(diff_data) + " " + str(diff_cv) +  "\n")
	    alph = alph * 1.5 # Increment alph
Ejemplo n.º 13
0
class StockTest(unittest.TestCase):

    def setUp(self):
        self.stock = Stock("INTC", "Intel Corporation", 20.50, 20.35)

    def test_get_name(self):
        self.assertEqual(self.stock.get_name(), self.stock._Stock__name)

    def test_get_symbol(self):
        self.assertEqual(
            self.stock.get_symbol(),
            self.stock._Stock__symbol
        )

    def test_get_price_close(self):
        self.assertEqual(
            self.stock.get_price_close(),
            self.stock._Stock__price_close
        )

    def test_get_price_current(self):
        self.assertEqual(
            self.stock.get_price_current(),
            self.stock._Stock__price_current
        )

    def test_get_change_percent(self):
        percent = self.stock.get_price_close() / \
                  self.stock.get_price_current()
        self.assertEqual(
            self.stock.get_change_percent(),
            -(1 - percent)
        )
Ejemplo n.º 14
0
def update(symbol):

    stock = Stock(symbol)
    #update stock
    if stock.update_history() == False:
        print 'this one is a dud'
        return False
    print 'got history'
    #if no data, discard
    #if data, add to list
    #calculate 52 week high
    #calculate n week average volume
    



    #return stock
    return stock
Ejemplo n.º 15
0
Archivo: main.py Proyecto: daicun/stock
def main():
    # try:
    #     sStock = Stock()
    #     code , result = sStock.getEqu(ticker = '000786')
    #     jDict = json.loads(result, encoding='utf-8')
    #     print 'jDict ticker: ' + jDict['data'][0]['ticker']
    #     print 'jDict officeAddr: ' + jDict['data'][0]['officeAddr'].encode('utf-8')
    # except Exception as e:
    #     raise e
    s = Stock()

    data = s.getEqu()
    if data is None:
        print 'get data object is failed'
    else:
        # print 'secID:           ' + data[0]['secID']
        # print 'ticker:          ' + data[0]['ticker']
        # print 'primeOperating:  ' + data[0]['primeOperating']
        # print 'TShEquity:       ' + str(data[0]['TShEquity'])
        for i in range(len(data)):
            print data[i]['secID'] + ': ' + data[i]['secShortName'] + ': ' + str(data[i]['TShEquity'])
Ejemplo n.º 16
0
def main():
    stock_names = ["ba", "cat", "dd", "ge", "gs", "ibm", "jnj", "jpm", "mmm", "xom"]

    Stocks = []
    for stock in stock_names:
        this_stock = Stock(stock, "../data")
        this_stock.populate()
        Stocks.append(this_stock)

    trainingData = learningData()
    trainingData.construct(Stocks, ["1/1/1980", [50, 100, 150], 50])
    trainingData.append(Stocks, ["1/1/1982", [50, 100, 150], 50])

    cv_data = learningData()
    cv_data.construct(Stocks, ["1/1/1990", [50, 100, 150], 50])
    cv_data.append(Stocks, ["1/1/1992", [50, 100, 150], 50])

    clf = linear_model.Ridge(alpha=0.1, fit_intercept=False)
    clf.fit(trainingData.X, trainingData.y)

    # To look for overfitting the code loops through values of alpha plotting distance between
    # the predicted values and actual data and various alphas
    alph = 0.01
    # filename = "output/filename.txt"
    # dir = os.path.dirname(filename)
    f = open("alpha.txt", "w")
    while alph < 0.2:
        # First fit the data for each alpha
        clf = linear_model.Ridge(alpha=alph, fit_intercept=False)
        clf.fit(trainingData.X, trainingData.y)
        # Now measure how close model comes for both training data and cross validation data
        # The clf.predict produces a vector with one element for each element in the sample
        predict_data = clf.predict(trainingData.X)
        predict_cv = clf.predict(cv_data.X)
        # The linagl function in np takes a L2 norm of the difference
        diff_data = (1.0 / trainingData.m) * np.linalg.norm(predict_data - trainingData.y)
        diff_cv = (1.0 / cv_data.m) * np.linalg.norm(predict_cv - cv_data.y)
        # Write out the values
        f.write(str(alph) + " " + str(diff_data) + " " + str(diff_cv) + "\n")
        alph = alph * 1.5  # Increment alph
Ejemplo n.º 17
0
    def download_nasdaq100_stock_info(self):

        stock_list = []
        request = urllib2.Request(self.nasdaq100_stock_url)
        request.add_header("User-Agent",
                           "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.116 Safari/537.36")
        response = urllib2.urlopen(request)
        resp_soup = BeautifulSoup(response.read(), "html.parser")
        ol_tag = resp_soup.find("ol")
        ol_tag_soup = BeautifulSoup(str(ol_tag).replace("\n", ""), "html.parser")
        li_tag_list = ol_tag_soup.find_all("li")
        for li_tag in li_tag_list:
            stock_str = unicode(li_tag.a["title"]).encode("utf-8") + unicode(li_tag.contents[1]).encode("utf-8")
            stock_name = stock_str[:stock_str.find("(")].lstrip().rstrip()
            stock_symbol = stock_str[stock_str.find("("):].replace("(", "").replace(")", "").lstrip().rstrip()
            stock = Stock()
            stock.name = stock_name
            stock.symbol = stock_symbol
            stock_list.append(stock)
            print stock.to_json()

        return stock_list
Ejemplo n.º 18
0
def simulation_for_single_stock(all_simulations, stock_file_path, stock_name_as_a_file):

    single_stock = Stock(stock_name_as_a_file.replace('.csv', ''))

    with open(stock_file_path, "r") as csv_file:
        data_reader = csv.reader(csv_file)
        for row in data_reader:
            if not row == []:
                #print(row)
                day_data = DayData(row[0], row[1], row[2], row[3], row[4], row[5])
                single_stock.add_data(day_data)

    good_data = 0
    has_2015 = False
    for day in single_stock.get_data():

        #print(day.get_open() <= 5.0)

        if day.get_open() >= 5.0:
            good_data += 1
        else:
            good_data -= 1
        if day.get_date().split('/')[2] == '2015':
            has_2015 = True

    # Filters.
    if has_2015:
        if good_data > 0:
            if len(single_stock.get_data()) >= 90:
                my_timer = Timer()
                my_timer.start_timer()
                do_math_for_single_stock(all_simulations, 5, 247, single_stock, 'LONG')
                do_math_for_single_stock(all_simulations, 5, 247, single_stock, 'SHORT')
                #do_math_for_single_stock(all_simulations, 5, 247, single_stock, 'COMBINED')
                my_timer.end_timer()
                my_timer.print_time()
Ejemplo n.º 19
0
def evaluate (x, ticker):
    inputData = Stock(ticker).getData()
    #print shit
    #print shit.shape
    output = neuralNetwork(x)
    
    #print np.transpose(input_data[0]).reshape(1,60).shape
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        
        saver = tf.train.Saver()
        saver.restore(sess, model)

        #print output.shape
        #print sess.run(output, feed_dict={x:shit})
        print sess.run(output, feed_dict={x:inputData})
Ejemplo n.º 20
0
def results2(days = 0):
    if (request.method == 'POST'):
        if request.form['submit_button'] == 'Do Something':
            return("owo")
        elif request.form['submit_button'] == 'Do Something Else':
            print(request.form['numBuy'])
            print(request.form['numShort'])
            for i in range(int(request.form['numBuy'])):
                myUserTwo.buyStock(Stock('AAPL'))
            print(myUserTwo.getStockList())
            print(request.form['buySell'])
            return("uwu")
        else:
            return("hehe")
        return render_template('index.html')
    return render_template('index.html')
    def __init__(self, n_days, n_steps_per_day, asset_config_path,
                 agent_config_path):
        self.n_days = n_days
        self.n_steps_per_day = n_steps_per_day

        initial_shares_per_agent = 10
        n_agents = AgentGenerator.n_agents(agent_config_path)
        print(n_agents)

        self.companies = CompanyGenerator.generate_companies(n_companies=10,
                                                             n_sectors=3)
        self.tickers = [each.ticker for each in self.companies]
        # self.tickers = 'EQNR DNO AKER MHG NRS LSG'.split(' ')
        # self.companies = []
        # for ticker in self.tickers:
        #     comp = Company(ticker=ticker,
        #                    n_shares=initial_shares_per_agent * n_agents,
        #                    cash=100 * initial_shares_per_agent * n_agents,
        #                    yield_policy=0.10)
        #     self.companies.append(comp)

        self.assets = [Stock(comp) for comp in self.companies]

        self.agents = AgentGenerator.generate(agent_config_path,
                                              self.assets,
                                              verbose=True)
        n_agents = len(self.agents)
        for agent in self.agents:
            for stock in self.assets:
                agent.portfolio.assets[stock] = initial_shares_per_agent

        self.cov_matrix = test.generate_corr_matrix(len(self.tickers), 2, 0.2)
        self.weights = np.ones(len(self.tickers))
        self.weights = self.weights / self.weights.size

        self.book = Orderbook([], [])

        # self.assets = ...

        self.timestamp = Timestamp(0, 0)

        self.market_portfolio = Portfolio.empty_portfolio(self.assets)
        self.exchange = Exchange(self.agents, self.market_portfolio,
                                 n_steps_per_day)

        self.history = []
Ejemplo n.º 22
0
	def put(self):
		try:
			s = Stock()
			price = self.get_argument('price','')
			quantity = self.get_argument('quantity','')
			if(price!=''):
				s.setEggPrice(float(price))
			if(quantity!=''):
				s.setEggQuantity(int(quantity))
			self.write("OK")
		except Exception as e:
			print(e)	
Ejemplo n.º 23
0
def get_stock_values(parser, section):
    """
    Get and save species values from configuration file.

    Args:
        parser (ConfigParser object): ConfigParser instance used as parser.
        section (str): Name of the section in configuration file corresponding
            to a specie.

    Returns:
        Stock object: Stock instance with specie's values.

    """
    options = parser.options(section)
    stock_data = {}
    for opt in options:
        stock_data[opt] = parser.get(section, opt)
    return Stock(stock_data)
Ejemplo n.º 24
0
    def test_stock_dividend_yield_common(self):
        """
        Tests correct dividend yield calculation for `common` stock types.
        """

        # Make a mock object for testing.
        sALE = Stock('ALE', 'common', 23, nan, 60)

        # A stock without trades has a default ticker price equal to its par
        # value.
        self.assertEqual(sALE.dividend_yield(), 23. / 60)

        # Add some mock Trades.
        sALE.buy(500, 25)
        sALE.sell(300, 15)
        self.assertEqual(len(sALE._trades), 2)

        # The dividend yield calculation should now use a ticker price
        # determined from the average trading price.
        self.assertEqual(sALE.dividend_yield(), 23. /
                         (((500*25)+(300*15))/(500+300)))
Ejemplo n.º 25
0
    def add_stocks(self, tickers):
        '''
        :type tickers: List[str]
        :return assets: List[Stock]
        '''
        assets = [None] * len(tickers)
        assets_str = [None] * len(tickers)

        for index, stock in enumerate(tickers):

            stock_obj = Stock(stock, self.AlphaVantage_Key)

            assets[index] = stock_obj
            assets_str[index] = stock

        self.curr_pf = self.curr_pf + assets
        self.list_pf = self.list_pf + assets_str
        
        return assets
Ejemplo n.º 26
0
    def accumulate_assets(self):
        """
        Run through the lots and count up how much of each stock we actually
        have. Store this in the dict assets.
        """

        self.asset_counts = dict()

        for l in self.lots:
            if l.stock.ticker not in self.asset_counts.keys():
                self.asset_counts[l.stock.ticker] = 0

            self.asset_counts[l.stock.ticker] += l.nr

        # Only bother doing this once.
        if not self.assets:
            self.assets = list()
            for a in self.asset_counts.keys():
                self.assets.append(Stock(a))
Ejemplo n.º 27
0
    def get_best_stocks(self, limit):
        if not os.path.exists(SR_FOLDER_PATH):
            os.makedirs(SR_FOLDER_PATH)
        file_name = SR_FOLDER_PATH + self.date_from + '-' + self.date_to + '.json'
        if os.path.isfile(file_name):
            with open(file_name) as file:
                stock_params = json.load(file)
        else:
            print('Create cache for new estimation period from ' +
                  self.date_from + ' to ' + self.date_to + '...')
            stock_params = []
            symbols = get_stock_symbols()

            for symbol in symbols:
                stock_param = self.get_sharped_ratio_by_stock(symbol)
                if stock_param is not None:
                    stock_params.append(stock_param)
            file = open(file_name, "w")
            file.write(json.dumps(stock_params))
            file.close()

        stocks_sorted_by_ret = sorted(stock_params,
                                      key=lambda x: x['ret'],
                                      reverse=True)[:self.stocks_with_max_ret]
        stocks_sorted_by_sharpe = sorted(stocks_sorted_by_ret,
                                         key=lambda x: x['sharpe'],
                                         reverse=True)
        first_10 = stocks_sorted_by_sharpe[:10]
        valid_count = self.get_valid_count(first_10)
        result = []
        current_stock_index = 0
        while len(result) < limit:
            stock_param = stocks_sorted_by_sharpe[current_stock_index]
            current_stock_index += 1
            quotes = get_stock_data_by_symbol(stock_param['symbol'])
            if len(quotes) != valid_count:
                continue
            info = self.get_stock_info_by_symbol(stock_param['symbol'])
            stock = Stock(info, quotes, stock_param)
            result.append(stock)

        return result
Ejemplo n.º 28
0
 def __init__(self, stockList, level):
     self.stockList = stockList
     self.level = level
     self.liquidAssets = 100000
     self.stocksBought = {stock: 0 for stock in stockList}
     self.stocksShorted = {stock: 0 for stock in stockList}
     self.stockValues = {
         ticker: Stock(ticker).getPrice()
         for ticker in stockList
     }
     self.totalAssets = 0
     self.ipo = {
         'AAPL': 22,
         'BLK': 14,
         'DIS': 13.88,
         'GE': 0.8,
         'JPM': 9.78,
         'MSFT': 21,
         'NYT': 42
     }
Ejemplo n.º 29
0
    def __init__(self, stock, start=None, end=None):
        if isinstance(stock, Stock):
            if (start is not None) and (end is not None):
                '''Raise Some exception that start/end dates were input'''
                print('Start/End won\'t be reset')
            stock = stock

        elif isinstance(stock, str):
            '''Include code to read in the Stock Object'''
            stock = Stock(stock, start=start, end=end)

        else:
            '''raise an InvalidInputType exception'''
            print('Invalid stock type')
            pass

        self.ticker = stock.ticker
        self.data = stock.data_table
        self.start_date = self.data.index.min()
        self.end_date = self.data.index.max()
Ejemplo n.º 30
0
def stock(update, context):
    if BOT_UPDATING:
        context.bot.send_message(chat_id=update.effective_chat.id,
                                 text='Bot Updating, Please Wait...')

    stock = Stock.Create(update.message.text[1:])
    if stock is not None:
        stock_message = ''
        if (stock.state == 0):
            stock_message = stock.stockInfo() + '\n' + stock.stockNews()
        elif (stock.state == 1):
            stock_message = 'No Such Stock Code [{:s}]'.format(stock.code)
        elif (stock.state == 2):
            stock_message = 'Yahoo Server Connect Failed'
        else:
            stock_message = 'Unknown Error'
        context.bot.send_message(chat_id=update.effective_chat.id,
                                 text=stock_message,
                                 parse_mode=telegram.ParseMode.HTML,
                                 disable_web_page_preview=True)
Ejemplo n.º 31
0
def load_stocks(folder, days):
    infos = []
    for root, dirs, files in os.walk(folder):
        for f in files:
            infos.append(f)
    infos.sort()
    for fname in infos[-days:]:
        f = open(folder + fname, 'r')
        count = 0
        for line in f:
            count += 1
            if count == 1: continue
            data = line.split(',')
            ticker = data[0]
            if ticker not in stocks:
                stocks[ticker] = Stock(ticker)
            d = data[1]
            day = date(int(d[:4]), int(d[4:6]), int(d[6:]))
            stocks[ticker].add_data(day, data[2], data[3], data[4], data[5],
                                    data[6])
Ejemplo n.º 32
0
def getKospi200():
	for i in range(1, 22, 1):
		try:
			url = baseUrl + str(i)
			r = requests.get(url)
			soup = BeautifulSoup(r.text, 'lxml')
			items = soup.find_all('td',{'class':'ctg'})
			
			for item in items:
				txt = item.a.get('href')
				k = re.search('[\d]+',txt)
				if k:
					code = k.group()
					name = item.text
					data = code, name
					kospi200Arr.append(Stock(code, name))
		except:
			pass

	return kospi200Arr
Ejemplo n.º 33
0
def get_stocks():
    """
    Open the csv file making sure the file can be opened
    """
    try:
        f = open('list.csv')
    except ValueError:
        print("Could not read {}".format('list.csv'))
        sys.exit()

    with f:
        reader = csv.reader(f)
        # loop through each row the csv file
        for row in reader:
            # create a dictionary
            stock_dict = {'name': row[0], 'tickler': row[1], 'price': row[2]}
            # create a stock object
            stock = Stock(stock_dict['name'], stock_dict['tickler'],
                          stock_dict['price'])
            # append the stock object to the list of stock
            stocks.append(stock)
Ejemplo n.º 34
0
def getStockByStockID(stockid):
    stocks = []
    conn = MySQLdb.connect(host='localhost',
                           user='******',
                           passwd='',
                           db='stockdb',
                           port=3306,
                           charset='utf8')
    cur = conn.cursor()
    cur.execute("select * from stocktable WHERE stockid='" + stockid +
                "' group by stockdate order by stockdate")
    result = cur.fetchall()
    for row in result:
        stocks.append(
            Stock(stockid=row[1],
                  stockname=row[2],
                  stockprice=row[3],
                  stockscore=row[4],
                  stockadvice=row[5],
                  stockdate=row[6]))
    return stocks
Ejemplo n.º 35
0
def getStockByDate(date,
                   host='localhost',
                   user='******',
                   passwd='',
                   db='stockdb',
                   port=3306):
    stocks = []
    conn = MySQLdb.connect(host, user, passwd, db, port, charset='utf8')
    cur = conn.cursor()
    cur.execute("SELECT * FROM stocktable WHERE stockdate='" + date +
                "' group by stockid order by stockid")
    result = cur.fetchall()
    for row in result:
        stocks.append(
            Stock(stockid=row[1],
                  stockname=row[2],
                  stockprice=row[3],
                  stockscore=row[4],
                  stockadvice=row[5],
                  stockdate=row[6]))
    return stocks
Ejemplo n.º 36
0
def read_data(stocks_collection, symbol):
    def skiplimit(collection, page_size=50, page_num=0):
        """returns a set of documents belonging to page number `page_num`
        where size of each page is `page_size`.
        """

        # Skip and limit
        cursor = collection.find({
            "symbol": symbol
        }).sort("date").skip(page_num * page_size).limit(page_size)
        return [DailyStock(x["date"], x["close"]) for x in cursor]

    daily_data = []
    page_num = 0
    data = skiplimit(stocks_collection, 200, page_num)

    while data:
        daily_data += data
        page_num += 1
        data = skiplimit(stocks_collection, 200, page_num)

    return Stock(symbol, daily_data)
Ejemplo n.º 37
0
def init_stocks():
    global fields

    # try to open file containing company list
    try:
        f1 = open(src_file, "r+")
        companies = f1.readlines()
        f1.close()
    except:
        bad_input()

    # try to open file containing desired fields
    try:
        f2 = open("data_mapping.json", "r+")
        fields = utils.file_to_dict(f2.readlines())
        f2.close()
    except:
        bad_input()

    # each stock will fetch data upon initialization
    for ticker in companies:
        stocks.append(Stock(ticker))
Ejemplo n.º 38
0
def grab_prices(symbol: str) -> object:
    """
    Get the current price for a given symbol
    """

    try:
        current_prices = get_last_price_data(symbol)
        now = get_last_trading_day()
        today = now.strftime("%Y-%m-%d")
        last_trading_day = current_prices[
            PricePayloadKeys.last_trading_day.value]
        if last_trading_day != today:
            print(last_trading_day)
            raise ValueError('Data for {0} is not available'.format(today))

        high = float(current_prices[PricePayloadKeys.high.value])
        low = float(current_prices[PricePayloadKeys.low.value])
        open_price = float(current_prices[PricePayloadKeys.open_price.value])
        close_price = float(current_prices[PricePayloadKeys.price.value])
        return Stock(high, low, close_price, open_price, symbol)
    except KeyError:
        print("JSON Response from AlphaVantage Corrupt")
Ejemplo n.º 39
0
def readDateStockDataFromDirs(path):
    stockDic = {}
    if not os.path.exists(path):
        return None
    fnames = os.listdir(path)
    for fname in fnames:
        stockDate = fname.split('.')[0]
        stockDic.setdefault(stockDate, [])
        f = open(path + '/' + fname)
        lines = f.readlines()
        for line in lines:
            stockDic[stockDate].append(Stock.parse(line))
    idDic = {}
    for d, s in stockDic.items():
        for stock in s:
            if stock.stockid not in idDic:
                idDic.setdefault(stock.stockid, [])
            idDic[stock.stockid].append(stock)

    for id, stocks in idDic.items():
        stocks.sort(key=lambda stock: stock.stockdate)
    return idDic
Ejemplo n.º 40
0
def graph_mean_reversion_default():

    # Constants
    k = 1.5
    num_days = 200
    time_span = 1000

    # List that holds the data
    stock_data = retrieve_list("input/custom.txt")

    # 2d arr, arr holds list of stocks throughout time span, each arr is a different stock
    stock_data_list = []

    # Go through backtest stocks
    for key in stock_data:
        temp = []
        for start in range(time_span, 0, -1):
            temp.append(Stock(key, stock_data[key], k, start, num_days))
        stock_data_list.append(temp)

    # Graph the historical data
    graph_mean_reversion(stock_data_list)
Ejemplo n.º 41
0
def update_db():
    """ filters tickers based on price and volume and etc """
    tickers = get_tickers(ALL_TICKERS_FILEPATH)
    stocks = []
    new_tickers = []

    for t in tickers:
        try:
            stock = Stock(t)
            if stock.avg_volume > MIN_VOLUME and stock.price > MIN_PRICE:
                stocks.append(stock)
                new_tickers.append(t)
                print(f'Added ${t} to db')
            else:
                print(
                    f'Skipped stock ${t}: avg_vol = ${stock.avg_volume}, price = ${stock.price}'
                )
        except Exception as e:
            print(f'Can\'t find ${t}', e)

    df = pd.DataFrame(new_tickers, columns=['ticker'])
    df.to_csv(FILTERED_TICKERS_FILEPATH, index=False)
Ejemplo n.º 42
0
    def parseCurrentHoldings(json):
        positionsParsed = []
        if (json is not None):
            for curHolding in json:
                try:
                    x = Stock(curHolding["instrument"]["symbol"])
                    x.purchasePrice = curHolding["averagePrice"]
                    x.plPercent = curHolding["currentDayProfitLossPercentage"]
                    x.plDollars = curHolding["currentDayProfitLoss"]
                    x.sharesHeld = curHolding["longQuantity"]
                    positionsParsed.append(x)

                except Exception as ex:
                    print("Couldn't parse order")
                    print(curHolding)

        return positionsParsed
Ejemplo n.º 43
0
def main():
	#enter a symbol and name 
	symbol = "INTC"
	name = "Intel Corporation"

	#enter previous and current prices 
	previousClosingPrice = 20.5
	currentPrice = 20.35

	#create stock object
	stock = Stock(symbol, name, previousClosingPrice, currentPrice)

	#display results
	print("The percentage of change for", stock.getSymbol(), stock.getName())
	print("Where the previous day's closing price was", stock.getPreviousClosingPrice())
	print("and the current day's closing price was", stock.getCurrentPrice())
	print("is", format(stock.getChangePercent(), ".2f"), "%")
Ejemplo n.º 44
0
class StockTest(unittest.TestCase):
    def setUp(self):
        self.stock = Stock("INTC", "Intel Corporation", 20.50, 20.35)

    def test_get_name(self):
        self.assertEqual(self.stock.get_name(), self.stock._Stock__name)

    def test_get_symbol(self):
        self.assertEqual(self.stock.get_symbol(), self.stock._Stock__symbol)

    def test_get_price_close(self):
        self.assertEqual(self.stock.get_price_close(),
                         self.stock._Stock__price_close)

    def test_get_price_current(self):
        self.assertEqual(self.stock.get_price_current(),
                         self.stock._Stock__price_current)

    def test_get_change_percent(self):
        percent = self.stock.get_price_close() / \
                  self.stock.get_price_current()
        self.assertEqual(self.stock.get_change_percent(), -(1 - percent))
Ejemplo n.º 45
0
 def verify(self):
     up5 = 0
     up1 = 0
     up9 = 0
     up = []
     chg_p = Stock.get_col().index("chg_p")
     for code in self.up_code:
         data_array = np.array(self.data[code])
         try:
             chg_p_array = np.float32(data_array[:, chg_p])
             if chg_p_array[-1] >= 1.0:
                 up1 += 1
                 up.append((code, chg_p_array[-1]))
             if chg_p_array[-1] >= 5.0:
                 up5 += 1
             if chg_p_array[-1] >= 9.0:
                 up9 += 1
         except:
             logging.error("%s failed" % code)
             trace_log()
     print "up5 = %.2f, up1 = %.2f, up9 = %.2f" % (
         float(up5) / float(len(self.up_code)), float(up1) /
         float(len(self.up_code)), float(up9) / float(len(self.up_code)))
     print up
Ejemplo n.º 46
0
def readStockRankFromDateDataDir(filepath):
    if not os.path.exists(filepath):
        return None
    fnames = os.listdir(filepath)
    stockrank = [i for i in range(len(fnames))]
    dateIndex = 0
    fnames.sort()
    for fname in fnames:
        resultDate = fname.split('.')[0]
        f = open(filepath + '/' + fname)
        lines = f.readlines()
        stockrank[dateIndex] = {}
        stockList = []
        for line in lines:
            stockList.append(Stock.parse(line.strip()))
        stockList.sort(key=lambda x: x.stockscore, reverse=True)
        rank = 1
        for stock in stockList:
            stockrank[dateIndex][stock.stockid] = (stock.stockid,
                                                   stock.stockscore,
                                                   resultDate, rank)
            rank += 1
        dateIndex += 1
    return stockrank
Ejemplo n.º 47
0
 def predict(self):
     result = {}
     for code in self.data:
         volume, chg_p, vma5, ma5, close, high = Stock.get_col().index(
             "volume"), Stock.get_col().index("chg_p"), Stock.get_col(
             ).index("vma5"), Stock.get_col().index("ma5"), Stock.get_col(
             ).index("close"), Stock.get_col().index("high")
         try:
             last_date = self.data[code][-1][0]
             if last_date != time.strftime("%Y-%m-%d", time.localtime()):
                 continue
         except:
             continue
         data_array = np.array(self.data[code])
         try:
             chg_p_array, vma5_array, volume_array, ma5_array, close_array, high_array = np.float32(
                 data_array[:, chg_p]), np.float32(
                     data_array[:, vma5]), np.float32(
                         data_array[:, volume]), np.float32(
                             data_array[:, ma5]), np.float32(
                                 data_array[:, close]), np.float32(
                                     data_array[:, high])
             # 判断跳空
             jumped = False
             for i in range(-1, -10, -1):
                 if high_array[i] < close_array[i - 1]:
                     jumped = True
                     break
             if jumped and chg_p_array[-1] > 3.0:
                 down_number = 0
                 for c in chg_p_array[-10:]:
                     if c < 0.0:
                         down_number += 1
                 result[code] = down_number
         except:
             trace_log()
             pass
     sorted_result = sorted(result.iteritems(),
                            key=operator.itemgetter(1),
                            reverse=True)
     return sorted_result
Ejemplo n.º 48
0
class DataReplayer(object):
    def __init__(self, symbol, date):
        self.stock = Stock(symbol=symbol, date=date)
        self.bars = []
        self.bar_idx = 0
        self.stock.fetch_chart()

    def calculate_bars(self):
        open_prices = self.stock.get_open_prices()
        close_prices = self.stock.get_close_prices()
        low_prices = self.stock.get_low_prices()
        high_prices = self.stock.get_high_prices()

        # theoretically these price collections have the same length
        lim = len(open_prices)
        for i in range(lim):
            bar = {
                'open': open_prices[i],
                'close': close_prices[i],
                'low': low_prices[i],
                'high': high_prices[i]
            }
            self.bars.append(bar)

    def print_next_bar(self):
        lim = len(self.bars)
        for i in range(lim):
            print(self.bars[self.bar_idx])
            self.bar_idx += 1
            sleep(1)

    def start_replay(self):
        self.calculate_bars()
        thread = Thread(target=self.print_next_bar)
        thread.start()
        thread.join()
Ejemplo n.º 49
0
from datetime import datetime, date
from sys import argv as argv
from stock import Stock
import os

start = datetime.now()
cur_time = datetime.now()

ticker_file = open(argv[1], 'r')
stocks = [Stock(ticker.strip()) for ticker in ticker_file]

header = '{0:>10}{1:>15}{2:>15}{3:>15}{4:>15}'.format('TICKER', 'DAY OPEN',
                                                      'LIVE PRICE', 'CHANGE',
                                                      '% Change')

while True:
    current = datetime.now()

    banner = '{0:^70}'.format(
        f'LAST UPDATED [{date.today()} {current.hour}:{str(current.minute).zfill(2)}:{str(current.second).zfill(2)}]'
    )
    output = banner + '\n' + header

    for stock in stocks:
        stock.update()
        output += '\n' + str(stock)
    output += '\n'

    os.system('cls')
    print(output)
Ejemplo n.º 50
0
 def test_sell(self):
     s = Stock('GOOG', 100, 490.1)
     s.sell(50)
     self.assertEqual(s.shares, 50)
Ejemplo n.º 51
0
#!/usr/bin/python
import logging

import sys
sys.path.append('lib')

from stock import Stock
from util import setup_logging

setup_logging()

stock = Stock()

report = stock.build_report()

for stn in report.stns():
    logging.info("Station: %s", stn.name)
    for loc in stn.locs():
        logging.info("  Location: %s", loc.name)
        for item in loc.items():
            output = []
            output.append("    %s: %d" % (item.name, item.have))
            if item.target > 0:
                output.append("/%d" % item.target)
                output.append(" (%.1f%%)" % item.percent)
            logging.info("".join(output))
Ejemplo n.º 52
0
 def test_set_price(self):
     s = Stock('GOOG', 100, 490.1)
     s.price = 10.0
     self.assertEqual(s.price, 10.0)
Ejemplo n.º 53
0
 def setUp(self):
     self.stock = Stock("INTC", "Intel Corporation", 20.50, 20.35)
Ejemplo n.º 54
0
 def test_bad_shares(self):
     s = Stock('GOOG', 100, 490.1)
     with self.assertRaises(TypeError):
         s.shares = 11.2
Ejemplo n.º 55
0
 def test_bad_price(self):
     s = Stock('GOOG', 100, 490.1)
     with self.assertRaises(TypeError):
         s.price = 'cookies'
 def setUp(self):
     self.goog = Stock('GOOG')
Ejemplo n.º 57
0
def strategy(symbol):
    stock = Stock(symbol)
    stock.update_history()
    stock.analyze()
    buy_dates = []
    buy_prices = []
    sell_dates = []
    sell_prices = []
    wiggly = piggy(sim=True,holdings=300)

    buy_flag = False
    staleness = 0
    sell_flag = False
    earn_flag = False
    last_bought = 0
    for itx, date in enumerate(stock.history_data['Date']):

        ptrn_lookahead = 5
        prox_thres = .02 * float(stock.history_data['Close'][itx])
        if float(stock.history_data['30_Day'][itx-ptrn_lookahead]) - prox_thres <= float(stock.history_data['10_Day'][itx-ptrn_lookahead]) <= float(stock.history_data['30_Day'][itx-ptrn_lookahead]) + prox_thres\
        and float(stock.history_data['30_Day'][itx-ptrn_lookahead]) - prox_thres <= float(stock.history_data['5_Day'][itx-ptrn_lookahead]) <= float(stock.history_data['30_Day'][itx-ptrn_lookahead]) + prox_thres\
        and float(stock.history_data['30_Day'][itx]) > float(stock.history_data['10_Day'][itx]) > float(stock.history_data['5_Day'][itx]):
            buy_flag = True
            staleness = 0
            
        gains_thres = 1.1
        buy_slop_err = 0.001
        if buy_flag \
        and float(stock.history_data['5_Day'][itx]) * gains_thres < float(stock.history_data['30_Day'][itx]) \
        and float(stock.history_data['5_Day'][itx]) > float(stock.history_data['5_Day'][itx-1]) * (1+buy_slop_err):  ##Once there is enough margin betweet the 5 day and 30 day, buy
            buy_dates.append(date)
            buy_prices.append(float(stock.history_data['Close'][itx]))
            buy_flag = False
            staleness = 0
            earn_flag = True
            num = int(wiggly.holdings * .5 / float(stock.history_data['Close'][itx]))
            wiggly.buy(stock,num,date=date)
            buy_dates.append(date)
            buy_prices.append(float(stock.history_data['Close'][itx]))
            last_bought = itx
 
        if (buy_flag
        and staleness > 20
        or (float(stock.history_data['5_Day'][itx]) > float(stock.history_data['10_Day'][itx]))):
            buy_flag = False
            staleness = 0

        earn_thres = 1.2
        if (earn_flag 
        and float(stock.history_data['10_Day'][itx]) > float(stock.history_data['10_Day'][itx-1]) * (1+buy_slop_err)
        and float(stock.history_data['Close'][itx]) > float(stock.history_data['5_Day'][last_bought]) * earn_thres): ## and the 5 Day is increasing, then throw the EARNING flag
            earn_flag = False
            sell_flag = True

        ceiling = .5
        if (sell_flag
        and float(stock.history_data['5_Day'][itx]) < float(stock.history_data['5_Day'][itx-1])) \
        or (sell_flag and float(stock.history_data['5_Day'][itx]) > float(stock.history_data['5_Day'][itx]) * (ceiling + 1)):
            sell_flag = False
            wiggly.sell(stock,-1,date=date)
            sell_dates.append(date)
            sell_prices.append(float(stock.history_data['Close'][itx]))

        staleness += 1


    if wiggly.current_stock[stock.symbol] > 0:
        print "\n\n#####Closing Out######"
        wiggly.sell(stock,-1,date=date)

    ##Make a plot
    import matplotlib.pyplot as plt
    import matplotlib.dates as plotdate
    import matplotlib.lines as line
    import numpy as np

    months    = plotdate.MonthLocator()   # every year
    days   = plotdate.DayLocator()  # every month
    monthsFmt = plotdate.DateFormatter('%m %d')

    fig, ax = plt.subplots()
    #ax2 = ax.twinx()
    t = [datetime.datetime.strptime(date,'%Y-%m-%d') for date in stock.history_data['Date']]
    ax.axis('auto')

    # format the ticks
    ax.xaxis.set_major_locator(months)
    ax.xaxis.set_major_formatter(monthsFmt)
    ax.xaxis.set_minor_locator(days)
    fig.autofmt_xdate()

    ax.plot(t, stock.history_data['5_Day'], '#0000FF')
    ax.plot(t, stock.history_data['10_Day'], '#5555FF')
    ax.plot(t, stock.history_data['30_Day'], '#9999FF')
    #ax.plot(t, stock.history_data['80_Day'], '#AAAAFF')
    #ax2.plot(t, stock.history_data['Volume'], '#CCFFCC')
    #ax2.plot(t, stock.history_data['10_Day_Vol'], '#88AA88')
    
    buy_dates = [datetime.datetime.strptime(date,'%Y-%m-%d') for date in buy_dates]
    ax.plot(buy_dates,buy_prices, 'g|',ms=100)

    sell_dates = [datetime.datetime.strptime(date,'%Y-%m-%d') for date in sell_dates]
    ax.plot(sell_dates,sell_prices, 'b|',ms=100)

    ax.plot(t, stock.history_data['Close'], 'r-')
    plt.title(stock.symbol)
    #ax.text(t[12], 250, 'hello')
    plt.show()
    return {'gains': wiggly.gains, 'symbol': stock.symbol, 'initial_value':stock.history_data['Open'][1]}
class StockTest(unittest.TestCase):
    """"""
    
    #----------------------------------------------------------------------
    def setUp(self):
        self.goog = Stock('GOOG')
        
    #----------------------------------------------------------------------
    def test_price_of_a_new_stock_class_should_be_None(self):
        self.assertIsNone(self.goog.price)
    
    #----------------------------------------------------------------------
    def test_stock_update(self):
        """
        An update should set the price on the stock object
        We will be using the `datetime` module for the timestamp
        """        
        self.goog.update(datetime(2014, 2, 12), price=10)
        self.assertEqual(10, self.goog.price)        
    
    #----------------------------------------------------------------------
    def test_negative_price_should_throw_ValueError(self):
        #self.assertRaises(ValueError, goog.update,
                          #datetime(2014, 2, 13), -1)
        with self.assertRaises(ValueError):
            self.goog.update(datetime(2014, 2, 13), -1)
    
    #---------------------------------------------------------------------
    def test_stock_price_should_give_the_latest_price(self):
        """"""
        self.goog.update(datetime(2014, 2, 12), price=10)
        self.goog.update(datetime(2014, 2, 13), price=8.4)
        self.assertAlmostEqual(8.4, self.goog.price, delta=0.0001)        
        
    #----------------------------------------------------------------------
    def given_a_series_of_prices(self, prices):
        """"""
        timestamps = [datetime(2014, 2, 10), datetime(2014, 2, 11), 
                      datetime(2014, 2, 12), datetime(2014, 2, 13)]
        for timestamp, price in zip(timestamps, prices):
            self.goog.update(timestamp, price)        
        
    #----------------------------------------------------------------------
    def test_increasing_trend_is_true_if_price_increase_for_3_updates(self):
        """"""
        self.given_a_series_of_prices([8, 10, 12])
        self.assertTrue(self.goog.is_increasing_trend())        
    
    #----------------------------------------------------------------------
    def test_increasing_trend_is_false_if_price_decreases(self):
        """"""
        self.given_a_series_of_prices([8, 12, 10])
        self.assertFalse(self.goog.is_increasing_trend())        
        
    #----------------------------------------------------------------------
    def test_increasing_trend_is_false_if_price_equal(self):
        """"""
        self.given_a_series_of_prices([8, 10, 10])
        self.assertFalse(self.goog.is_increasing_trend())        
    
    #----------------------------------------------------------------------
    def test_price_is_the_latest_even_if_updates_are_made_out_of_order(self):
        """"""
        self.goog.update(datetime(2014, 2, 13), price=8)
        self.goog.update(datetime(2014, 2, 12), price=10)
        self.assertEqual(8, self.goog.price)      
Ejemplo n.º 59
0
 def test_set_shares(self):
     s = Stock('GOOG', 100, 490.1)
     s.shares = 50
     self.assertEqual(s.shares, 50)