def coin(self): from coinmarketcap import Market coinmarketcap = Market() text = time.strftime("%I:%M:%S %p", \ time.localtime(int(coinmarketcap.ticker('bitcoin', convert="CNY")\ [0]['last_updated']))) + " updated\n\n" text += "\033[7;37;40mSym Rank %Cper Prc \ Changes \033[0m \n" for c in [ 'bitcoin', 'ethereum', 'ripple', 'bitcoin-cash', 'litecoin', 'EOS', 'bitcoin-gold', 'qtum', 'bitshares', 'binance-coin', 'digixdao', 'gxshares', 'decentraland' ]: msg = coinmarketcap.ticker(c, convert="CNY")[0] text += msg["symbol"].lower() + "\t" + msg["rank"] + "\t" + \ str("%.8f"%float(msg["price_btc"])) + "\t" + \ " " * (8-len(str("%.2f"%float(msg["price_cny"])))) + \ str("%.2f"%float(msg["price_cny"])) + "\t" + \ " " * (7-len(str("%.2f"%float(msg['percent_change_1h'])))) + \ str("%.2f"%float(msg['percent_change_1h'])) + " /" +\ " " * (7-len(str("%.2f"%float(msg['percent_change_24h'])))) + \ str("%.2f"%float(msg['percent_change_24h'])) + " /" +\ " " * (7-len(str("%.2f"%float(msg['percent_change_7d'])))) + \ str("%.2f"%float(msg['percent_change_7d'])) + "\n" return text
def messaged_ticker(self, ticker_call): currency_dict = { "€": ["EUR", "price_eur", "market_cap_eur", "€"], "£": ["GBP", "price_gbp", "market_cap_gbp", "£"], "$": ["dollar", "price_usd", "market_cap_usd", "$"], "฿": ["bitcoin", "price_btc", "market_cap_usd", "$"], "Ƀ": ["bitcoin", "price_btc", "market_cap_usd", "$"] } coinmarketcap = Market() currency = ticker_call[0] out_curr = (currency_dict[currency][0]) ticker1 = ticker_call[1:] if currency == '€' or '£': crypto_market = coinmarketcap.ticker(convert=out_curr) else: crypto_market = coinmarketcap.ticker(convert="") if currency == "฿": currency = "Ƀ" coin_data = self.sym_to_list(ticker1, crypto_market) if coin_data == False: return False url_name = self.list_to_id(coin_data) try: if currency != "Ƀ": self.ticker_info = ( coin_data.get('name') + '\n' 'Price: ' + currency + " {:0,.2f}".format( float(coin_data.get(currency_dict[currency][1]))) + '\n' '1h: ' + coin_data.get('percent_change_1h') + ' %' + '\n' '24h: ' + coin_data.get('percent_change_24h') + ' %' + '\n' '7d: ' + coin_data.get('percent_change_7d') + ' %' + '\n' 'Market Cap: ' + currency_dict[currency][3] + ' {:0,.2f}'.format( float(coin_data.get(currency_dict[currency][2])))) else: self.ticker_info = ( coin_data.get('name') + '\n' 'Price: ' + currency + " {:0,.8f}".format( float(coin_data.get(currency_dict[currency][1]))) + '\n' '1h: ' + coin_data.get('percent_change_1h') + ' %' + '\n' '24h: ' + coin_data.get('percent_change_24h') + ' %' + '\n' '7d: ' + coin_data.get('percent_change_7d') + ' %' + '\n' 'Market Cap: ' + currency_dict[currency][3] + ' {:0,.2f}'.format( float(coin_data.get(currency_dict[currency][2])))) except: self.ticker_info = 'Error, not found' return self.ticker_info
def main(): coinmarketcap = Market() markets_coin = coinmarketcap.ticker(limit=20) coins = [] for i in range(0, 20): coins.append( Coin(name=markets_coin[i]['name'], accronym=markets_coin[i]['symbol'], in_usd=markets_coin[i]['price_usd'], available_supply=markets_coin[i]['available_supply'], total_supply=markets_coin[i]['total_supply'])) print("\033c") for i in coins: sys.stdout.write(str(i)) time.sleep(20) while (True): count_coin = 0 markets_coin = coinmarketcap.ticker(limit=20) for i in coins: i.update(markets_coin[count_coin]['price_usd']) count_coin += 1 print("\033c") for i in coins: sys.stdout.write(str(i)) time.sleep(20)
def coinmarketcap(): try: cmc = Market() for currency in currency_list: try: price_data = cmc.ticker(1567, convert=currency.upper()) data_name = currency.upper() price_currency = price_data['data']['quotes'][data_name][ 'price'] print( rdata.hset("prices", "coinmarketcap:nano-" + currency.lower(), price_currency), "Coinmarketcap NANO-" + currency.upper(), price_currency) except: exc_type, exc_obj, exc_tb = sys.exc_info() print('exception', exc_type, exc_obj, exc_tb.tb_lineno) print("Failed to get price for NANO-" + currency.upper() + " Error") price_data = cmc.ticker(1567, convert='BTC') price_btc = price_data['data']['quotes']['BTC']['price'] print(rdata.hset("prices", "coinmarketcap:nano-btc", price_btc), price_btc) print( rdata.hset("prices", "coinmarketcap:lastupdate", int(time.time())), int(time.time())) except: exc_type, exc_obj, exc_tb = sys.exc_info() print('exception', exc_type, exc_obj, exc_tb.tb_lineno) print("Failed to load from CoinMarketCap")
def scrapeCoin(index,dbloc): #Create market API instance coinmarketcap = Market() #Scrape relevant data bitcoin = coinmarketcap.ticker("bitcoin") litecoin = coinmarketcap.ticker("litecoin") vertcoin = coinmarketcap.ticker("vertcoin") #Load into variables btcout = bitcoin[0] ltcout = litecoin[0] vtcout = vertcoin[0] #Create coin array and dictionary coins = ["'Bitcoin'","'Litecoin'","'Vertcoin'"] coinDict = {"Bitcoin":0, "Litecoin":0, "Vertcoin":0} #Load values into dictionary if index == 0: coinDict["'Bitcoin'"] = btcout["price_usd"] elif index == 1: coinDict["'Litecoin'"] = ltcout["price_usd"] elif index == 2: coinDict["'Vertcoin'"] = vtcout["price_usd"] return coinDict[coins[index]]
def main(arguments): parser = argparse.ArgumentParser() parser.add_argument('currency', help="curency") parser.add_argument('key', help="Выводимый ключ") parser.add_argument('convert', help="convert to", default='USD') args = parser.parse_args(arguments) print(args.currency) coinmarketcap = Market() print(coinmarketcap.ticker(args.currency, limit=1, convert=args.currency)) print( coinmarketcap.ticker(args.currency, limit=1, convert=args.currency)[0].get(args.key))
def _convert_usd(self, currency): market = Market() if currency != 'USD': buy_price_USD = float(market.ticker(self.name)[0]['price_usd']) else: buy_price_USD = self.buy_price return buy_price_USD * self.quantity
class Statistics: def __init__(self, default): self.market = Market() self.default = default def get_best_asset(self, period, ticker_range): best_asset_symbol = self.default best_asset_percentage = 0 response = self.market.ticker(limit=100, convert='USD') ticker_list_length = len(response) for i in range(0, ticker_list_length): item = response[i] if item["symbol"] in str(ticker_range): if period == PeriodRange.HOUR: if float(item["percent_change_1h"]) > float(best_asset_percentage): best_asset_symbol = item["symbol"] best_asset_percentage = item["percent_change_1h"] elif period == PeriodRange.DAY: if float(item["percent_change_24h"]) > float(best_asset_percentage): best_asset_symbol = item["symbol"] best_asset_percentage = item["percent_change_24h"] elif period == PeriodRange.WEEK: if float(item["percent_change_7d"]) > float(best_asset_percentage): best_asset_symbol = item["symbol"] best_asset_percentage = item["percent_change_7d"] return best_asset_symbol
def get_weights(coins, fiat_currency): coinmarketcap = Market() market_cap = {} for c in coins: try: listings = coinmarketcap.listings() print(listings['data'][0]) id = [ item['id'] for item in listings['data'] if item['symbol'] == c ][0] ticker = coinmarketcap.ticker(id) print(ticker) market_cap[c] = \ float(ticker['data']['quotes'][fiat_currency]['market_cap']) except HTTPError as e: print('caught exception when fetching ticker for {} with name={}'. format(c, coins[c]['name'])) raise e total_market_cap = sum(market_cap.values()) weights = {} for c in coins: weights[c] = market_cap[c] / total_market_cap print('coin weights:') for w in weights: print(' {0}: {1:.4f}'.format(w, weights[w])) print() return weights
def symbol_id_list(): coinmarketcap = Market() api_result = coinmarketcap.ticker(start=0, limit=0, convert='krw') for coin in api_result: # loop over arrays coin_name = coin['id'] coin_symbol = coin['symbol'] symbol = Symbol.objects.create(coin_name=coin_name, symbol=coin_symbol)
def collect_data(currency_name, price_list): coinmarketcap = Market() data = coinmarketcap.ticker(currency_name, limit=3, convert='USD') data = data.pop(0) now_time = datetime.now() now_time = str(now_time.strftime('%Y/%m/%d %H:%M')) data_list = [now_time] for key, value in data.items(): if key == 'price_usd': value = float(value) data_list.append(value) if value > price_list[-1]: # Här kan vi skapa flera fält för att se till olika lagg data_list.append(1) else: data_list.append(0) price_list.append(value) elif key == 'price_btc': data_list.append(value) elif key == '24h_volume_usd': data_list.append(value) elif key == 'percent_change_1h': data_list.append(value) elif key == 'percent_change_24h': data_list.append(value) elif key == 'percent_change_7d': data_list.append(value) return data_list
def post_update_all(request): #symbol_id_list() user = request.user.id coin_dicts = Post.objects.filter( published_date__lte=timezone.now(), author_id=user).order_by('published_date').values( 'coin_name', 'quantity', 'id') for coin_dict in coin_dicts: post = Post.objects.get(published_date__lte=timezone.now(), id=coin_dict['id']) coinmarketcap = Market() coin = (coinmarketcap.ticker(coin_dict['coin_name'], convert='KRW'))[0] post.total_price_krw = float(coin["price_krw"]) * float( coin_dict['quantity']) post.price_krw = int(float(coin["price_krw"])) print(post.price_krw) post.price_usd = coin["price_usd"] post.price_btc = coin["price_btc"] post.author = request.user post.publish() post.save() print(post.coin_name, post.total_price_krw, post.price_krw) posts = Post.objects.filter(published_date__lte=timezone.now(), author_id=user).order_by('published_date') return render(request, 'blog/post_list.html', {'posts': posts})
def choose(bot, update, user_data): coin = Market() data = coin.ticker(1, convert="USD") price = str(data["data"]["quotes"]["USD"]["price"]) update.message.reply_text(text="Ціна бітка станом на сьогодні: \n" + price + " USD") print('here')
async def handle(client, config, message): if not is_channel_valid(config, 'crypto_channels', message): return if not has_prefix(config, message): return content = get_content_without_prefix(config, message) command_args = content.split() if len(command_args) != 2: return if command_args[0] != 'val': return client.send_typing(message.channel) command_args[1] = command_args[1].upper() if command_args[1] in currency_mapping: coin_market = Market() try: data = coin_market.ticker(currency_mapping[command_args[1]], limit=1, convert='CAD')[0] await client.send_message(message.channel, embed=__create_message(data)) except Exception as err: await client.send_message( message.channel, 'There was an error fetching the value of %s!' % command_args[1]) print('Error fetching token %s' % command_args[1]) print('%s\n' % err) else: await client.send_message(message.channel, 'Token %s not found!' % command_args[1])
def recebe_xrp(lista_xrp): market = Market() ticker = market.ticker(convert="BRL") data = ticker['data']['52']['quotes']['USD']['price'] xrp = data lista_xrp.append(xrp) return lista_xrp
def getMarketPrice(self): coinmarketcap = Market() listings = coinmarketcap.ticker() for symbolOn in listings['data'].items(): if symbolOn[1]['symbol']==self.symbol: return symbolOn[1]['quotes']['USD']['price'] return 0.0
def main(): print(""" -- DASH CORRUPTED GOVERNANCE ATTACK SIMULATOR -- -- Please provide customised information for any parameter OR -- Press enter to proceed with the real time values -- """) # Retrieves Dash real time data. cmc = Market() coins = cmc.ticker(limit=20) dash = '' for i in range(0, 20): if coins[i]['id'] == 'dash': dash = coins[i] break # Retrieves master nodes real time data. mn_stats = 'https://stats.masternode.me/network-report/latest/json' req_stats = Request(mn_stats, headers={'User-Agent': 'Mozilla/5.0'}) stats = json.loads(urlopen(req_stats).read().decode("utf-8")) i = 1 # Keep looping with same questions unless data in correct form is provided. while True: price = input( 'Customised Price($): (press enter for real time price) ') exp = input( 'Price Increase Factor (1-10)(1: Aggressive, 10: Slow): (press enter for default factor) ' ) mn = input( 'Number of Active Masternodes: (press enter for real time active MN) ' ) coins = input( 'Coins in Circulation (in Millions): (press enter for real time circulation) ' ) num_mn = input( 'How many masternodes you want to control?: (press enter for net 10% malicious MN) ' ) try: price = float(price) if price else float(dash['price_usd']) exp = float((int(exp) + 5) * -1) if exp and (int(exp) > 0 and int(exp) < 11) else float(-11.4) exp_incr = math.pow(math.e, exp) mn = int(mn) if mn else stats["raw"]["mn_count"] coins = float(coins * 1000000) if coins else float( dash['available_supply']) num_mn = int(num_mn) if num_mn else int((mn * 1.1) + 1) break except ValueError: pass while i <= price: ... i += 1 report(price, exp_incr, mn, coins) cost, new_price = buy_X_MN(num_mn, price, exp_incr, coins, mn) print()
def recebe_btc(lista_btc): market = Market() ticker = market.ticker(convert="BRL") data = ticker['data']['1']['quotes']['USD']['price'] btc = data lista_btc.append(btc) return lista_btc
def get_currency_stats(cur_list): req = urllib.request.Request("https://api.coinmarketcap.com/v1/ticker/") opener = urllib.request.build_opener() f = opener.open(req) jso = json.loads(f.read().decode('utf-8')) total_bal = [] for ci in cur_list: for cp in jso: if cp['symbol'] == ci['currency']: price_usd = float(cp['price_usd'].encode('utf-8')) cur_bal = float(ci['Balance']) usd_balance = price_usd * cur_bal total_bal.append(usd_balance) print(cp['name']+ ' $'+ str(usd_balance)) coin_market = CMC.ticker(cp['id'])[0] print('Rank '+ coin_market['rank'],end=' | ') print('1HR %'+ coin_market['percent_change_1h'],end=' | ') print('24HR % '+ coin_market['percent_change_24h'],end=' | ') try: print('7D %'+ coin_market['percent_change_7d']) except: print('No Data') print("="*60) total_bal = reduce(lambda x, y: x+y, total_bal) total_bal = 'Balance $'+str(total_bal) return total_bal
class Coins(object): def __init__(self): self.coinmarketcap = Market() self.current_reference = 'BTC' def _parseresponse(self, response): result = [] for coin in response['data'].keys(): res_coin = {} for field, val in response['data'][coin].items(): if isinstance(val, dict): for currency in response['data'][coin][field].keys(): res_coin.update({ x + '_' + currency: y for x, y in response['data'][coin][field] [currency].items() }) else: res_coin[field] = val result.append(res_coin) return result def get_coins_summary(self, start=0, limit=100): raw_data = self.coinmarketcap.ticker(start=start, limit=limit, convert=self.current_reference) data = pd.DataFrame(self._parseresponse(raw_data)) data['DATETIME'] = pd.to_datetime('today').strftime("%Y-%m-%d") return data
def getCoinData(coin): cap = Market() data = cap.ticker(coin) if data == {'error': 'id not found'}: return None return data[0]
class Strategy: def __init__(self, exchange=None, **kwargs): print('Strategy initializing...') self.exchange = exchange if exchange else DEFAULT_EXCHANGE self.type = ROLLBACK self.purchase_different_coins = 4 # 3-10 recommended self.drop_range_to_buy_pct = range(-40, -10) self.deposit_threshold_pct = 50 self.capitalization_threshold_usd = float(20000000.0) # > 30 billions recommended self.market_volume_threshold_usd_24h = 500000 self.your_margin_pct = 5 self.market = Market() self.drops = None self.suitable_coins_marketcap = {} self.suitable_tickers = [] self.coins_listing = {item['symbol']: {'id': item['id'], 'name': item['name']} for item in self.market.listings()['data']} self.crypto_only = False # include tokens, ico etc. self.currencies = None self.profit_policy = HALF_REINVEST for key in kwargs: if hasattr(self, key): setattr(self, key, kwargs[key]) def fetch_currencies(self): curs = self.exchange.fetch_currencies() if self.crypto_only: curs = dict((k + '/' + BASE_TICKER, v) for k, v in curs.items() if v['type'] == 'crypto') else: curs = dict((k + '/' + BASE_TICKER, v) for k, v in curs.items()) self.currencies = curs def fetch_suitable_coins(self): self.fetch_currencies() try: tickers = self.exchange.fetch_tickers() except: tickers = {} self.drops = {pair: data for pair, data in tickers.items() if pair.endswith(BASE_TICKER) and data['percentage'] is not None and int(data['percentage']) in self.drop_range_to_buy_pct and pair in self.currencies} if self.market: for pair, market_data in self.drops.items(): ticker = pair.split('/')[0] if ticker in self.coins_listing: market_cap_id = self.coins_listing[ticker]['id'] if bool(market_cap_id): market_data = self.market.ticker(market_cap_id, convert=USD)['data']['quotes'][USD] capital = market_data['market_cap'] if isinstance(capital, float): if capital >= self.capitalization_threshold_usd: print(ticker, self.coins_listing[ticker]['name'], capital) self.suitable_coins_marketcap[ticker] = capital else: print('Capitalization is unknown: {}... pass'.format(ticker)) if len(self.suitable_coins_marketcap) > 0: scm = self.suitable_coins_marketcap self.suitable_tickers = sorted(scm, key=scm.get, reverse=True)[:self.purchase_different_coins]
def get_coin_data(self): coinmarketcap = Market() coin_data = coinmarketcap.ticker(limit=300, convert='EUR') coin_data = coin_data['data'] coin2eur = {d['symbol']: d['quotes']['EUR']['price'] for d in coin_data.values()} coin2eur = helpers.recursive_replace(coin2eur, coin_thesaurus) self.coin2eur = self.sort_dict_desc(coin2eur) return coin_data
def get_coin(coin=None): """ Get Price of Coin by USD """ for i in coins: if coin.upper() == i['symbol']: coinmarketcap = Market() coin_info = coinmarketcap.ticker(currency=i['id'], convert='USD') return coin_info[0] return None
def coinmarket(self, symbol, message): coinmarketcap = Market() try: result = coinmarketcap.ticker(symbol, limit=3, convert='EUR') except: return self.getCoinNotFoundError(message, 'Id not found') return self.handle_result_coinmarket(result)
def get_current_crypto_price(crypto_name): coinmarketcap = Market() data = coinmarketcap.ticker()["data"] for chunk in data: name = data[chunk]["symbol"] price = data[chunk]["quotes"]["USD"]["price"] if name == crypto_name: return price
def getAllMarkets(limit=None): cap = Market() if not limit: stats = cap.stats() limit = stats['active_currencies'] + stats['active_assets'] return cap.ticker(limit=limit)
def price(): b = BtcConverter() bitcoin_price = b.get_latest_price('USD') coinmarketcap = Market() y = coinmarketcap.ticker(start=0, limit=2, convert='USD') return { "btc": bitcoin_price, "eth": y["data"]["1027"]["quotes"]['USD']['price'] }
def recebe_btc(lista): market = Market() ticker = market.ticker(convert='BRL') data = ticker['data'] btc = data['1']['quotes']['BRL']['price'] lista.append(btc) return lista
def __init__(self): click.secho("[*] Getting Coinmarketcap data... ", nl=False) coinmarketcap = Market() dogecoin = coinmarketcap.ticker("Dogecoin", limit=3, convert="USD")[0] self.usdprice = dogecoin["price_usd"] self.btcprice = dogecoin["price_btc"] self.rank = dogecoin["rank"] self.supply = dogecoin["total_supply"] click.secho("Done", fg="green")
import json import os from datetime import datetime from coinmarketcap import Market from apscheduler.schedulers.blocking import BlockingScheduler coin_market = Market() json_data = coin_market.ticker().decode('utf-8') data = json.loads(json_data) path = 'Data' poloniex_symbols = ['ETH', 'XRP', 'ETC', 'GNT', 'STR', 'DOGE', 'XEM', 'LTC', 'DGB', 'XMR', 'ZEC', 'SC', 'BCN', 'DASH', 'BTS', 'BTM', 'FCT', 'STEEM', 'STRAT', 'REP', 'LSK', 'SYS', 'NXT', 'MAID', 'GAME', 'ARDR', 'RIC', 'GNO', 'DCR', 'AMP', 'VTC', 'CLAM', 'BURST', 'BCY', 'LBC', 'SJCX', 'NAV', 'PINK', 'BTCD', 'EXP', 'PPC', 'XCP', 'NEOS', 'NAUT', 'POT', 'PASC', 'BELA', 'EMC2', 'BLK', 'FLO', 'FLDC', 'NMC', 'GRC', 'XVC', 'XPM', 'OMNI', 'SBD', 'XBC', 'NXC', 'VRC', 'HUC', 'NOTE' ] def increasing(): for coin in data: if coin['percent_change_1h'] is not None: #check for volume over $1 million dollars if float(coin['24h_volume_usd']) > 1000000: percent_change_1h = float(coin['percent_change_1h']) if percent_change_1h > 10: print (coin['name'])
class Cerberus(object): def __init__(self, n_streams, master_lock, mode, keychain, loki): self.nP = n_streams self.mode = mode self.totalScore = 0 self.lock = master_lock self.oracle = Oracle(keychain, loki) self.json_db_filename = json_db self.SQL_db_filename = sql_db self.nbatches = 0 self.market = Market() self.initResources() def initResources(self): self.stacks = [Queue() for _ in range(self.nP)] if self.mode == 'mongo': self.client = MongoClient() self.db = self.client[mongo_db] if self.mode == 'SQL': self.db = self.SQL_db_filename self.conn = _sqlite3.connect(self.SQL_db_filename) self.curs = self.conn.cursor() self.curs.execute("CREATE TABLE IF NOT EXISTS tweets (tid integer, username text, cat text, content text, coordinates text, sentiment text, source text)") if self.mode == 'JSON': self.db = self.json_db_filename def db_count(self, table): r_query = "SELECT Count() FROM %s" % table self.curs.execute(r_query) n_rows = self.curs.fetchone()[0] return n_rows def handleNewTweet(self, pID, pDesc, tweet): self.lock.acquire() try: self.stacks[int(pID)].put(tweet) except Exception as e: print 'caught', e, 'while handling new entry' finally: self.lock.release() def printScore(self, batchc): if self.mode == 'mongo': name = self.mode + '.' + self.db.name dbc = sum([self.db[cname].count() for cname in self.db.collection_names()]) else: name = self.db dbc = self.db_count('tweets') batch_number = 'Batch ' + str(self.nbatches) announcement = ' Wrote ' + str(sum(batchc)) + \ ' entities to ' + str(name) + ' for a total of ' + str(dbc) + ' ' statistics = str(batchc) l = len(announcement) t1 = int((l - len(batch_number))/2) t2 = int((l - len(statistics))/2) print '' print t1*'-', batch_number, (l-len(batch_number)-t1)*'-' print announcement print t2*'-', statistics, (l-len(statistics)-t2)*'-' def readFromJSON(self): json_file = open(self.json_db_filename,'r') json_data = json.load(json_file) json_file.close() return json_data, len(json_data) def writeToJSON(self, json_data): json_file = open(self.json_db_filename,'w') json_file.write(json.dumps(json_data)) json_file.close() return len(json_data) def executeBatch(self, dbs): self.lock.acquire() self.dbs = dbs self.nbatches += 1 buffers = [] batch_cnt = [] try: for i, stack in enumerate(self.stacks): buf = [] while not stack.empty(): tweet = stack.get(timeout = 3) buf.append(tweet) buffers.append(buf) batch_cnt.append(len(buf)) if len(buffers): if self.mode == 'JSON': json_data = [] try: json_data, u = self.readFromJSON() except Exception as e: print e, 'exception caught while writing to JSON' for buf in buffers: for tweet in buf: json_data.append({'user': tweet.userID, 'tweet': tweet.tweetID, 'text': tweet.text, 'created_at': str(tweet.createdAt), 'location': tweet.location, 'source': tweet.device}) self.writeToJSON(json_data) score = len(buf) self.totalScore += score self.printScore(score, self.totalScore) if self.mode == 'SQL': for buf in buffers: for tweet in buf: self.curs.execute("insert into tweets (tid, username, content, cat, /" "coordinates, sentiment, source) values(?, ?, ?, ?, ?, ?, ?)", (tweet.tweetID, tweet.userID, tweet.text, str(tweet.createdAt), tweet.location, tweet.sentiment, tweet.device)) self.conn.commit() self.printScore(batch_cnt) if self.mode == 'mongo': score = 0 for i, buf in enumerate(buffers): col = self.dbs[i] objs = [] for obj in buf: cat = date_convert(obj.json['created_at']) objs.append({'created': cat, 'payload':obj.json}) try: if len(objs): self.db[col].insert_many(objs) except Exception as e: print(e) raise try: price = {'created': datetime.now() - timedelta(hours = 3), 'payload':self.market.ticker(col)[0]} self.db[col+'_price'].insert_one(price) except Exception as e: print(e) raise self.printScore(batch_cnt) except Exception as e: print type(e).__name__,'exception caught while writing to database' finally: self.lock.release() return batch_cnt def reboot(self): del self.stacks self.executeBatch() self.initResources()
from coinmarketcap import Market import coinmarketcap c = CurrencyRates() b=BtcConverter() m=Market() cc=CurrencyCodes() allcoins={} curlist=list(c.get_rates("USD").keys()) #print(c.get_rates("USD")) curlist.append("USD") curlist.sort() for cur in curlist: allcoins[cur]=cc.get_currency_name(cur) altcoinmap={} #print (coinmarketcap.price("BTC")) json=m.ticker(convert='EUR') #print(json) for currency in json: altcoinmap[currency["symbol"]]=currency["id"] allcoins[currency["symbol"]]=currency["name"] #print(altcoinmap) #print(json) #print(m.ticker("bitcoin",convert="EUR")[0]["price_usd"]*100) allcoins=SortedDict(allcoins) wordhash={} credithash={} initialvalue=100000.00 investfile = '/home/bananapi/.sopel/modules/invest.xml'
config = configparser.ConfigParser() config.read(os.path.join(os.path.expanduser('~'), '.config', 'me.ini')) # prepare database connection dburl = config['db']['url'] engine = create_engine(dburl) # get coin market cap data coinmarketcap = Market() # Since data is falling quite a bit, temporarly check if we got # it, and if not, increase the limit of records returned. contains_data = False limit = 125 while not contains_data: markets = coinmarketcap.ticker(limit=limit, convert='EUR') mktdf = pd.DataFrame(markets) if len(mktdf[mktdf.symbol == 'DATA']) > 0: contains_data = True limit += 10 mktdf = pd.DataFrame(markets) # convert some columns nonnumeric = ['cached', 'id', 'name', 'symbol'] for col in [numcol for numcol in mktdf.columns if numcol not in nonnumeric]: mktdf[col] = pd.to_numeric(mktdf[col]) # add a read date and save current values to the database mktdf['read_date'] = current_date mktdf = mktdf[['read_date'] + list(mktdf.columns[:-1])]