diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..0f859f3 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "python.pythonPath": "/Library/Frameworks/Python.framework/Versions/3.9/bin/python3" +} \ No newline at end of file diff --git a/Crypto Bot Vignette.ipynb b/Crypto Bot Vignette.ipynb new file mode 100644 index 0000000..eaa25f0 --- /dev/null +++ b/Crypto Bot Vignette.ipynb @@ -0,0 +1,349 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "894c8332", + "metadata": {}, + "source": [ + "# Crypto Bot" + ] + }, + { + "cell_type": "markdown", + "id": "38dd6abc", + "metadata": {}, + "source": [ + "Disclaimer: This software is built solely as an educational bot. It is not intended to provide any financial advice. DON?T FOLLOW WHAT THIS BOT SUGGESTS. Make your own research and make your own decisions.\n", + "\n", + "[TL;DR]\n", + "This package allows you to:\n", + "- See the live price of your crypto (number or graph)\n", + "- See historical price of your crypto\n", + "- Get an automated technical analysis suggestion of buying/selling/retaining your crypto\n", + "\n", + "\n", + "Crypto Bot is a resource that allows users to keep track of their favorite cryptocurrencies in real time, observe historical data and get algorithmic technical analysis insight into the market - should you buy, retain or sell at this moment? No worries, just set your parameters in the GUI and the bot will help you make less emotional decisions.\n", + "\n", + "Most cryptocurrencies from the market are available - unless you want to choose the one that the cousin of your neigbor is just starting to code. We don't have acces to that one, yet. Historical data can be retrieved in 24 hours intervals for any time range that doesn't exceed two years. If you want to get historical data from 1h intervals, the limit is data from month in the past. \n", + "Additionally, the GUI has a programmed trading bot that will be making suggestions so that you can know when is it the best time to sell/buy/retain. \n", + "Note: The technical indicator in this bot is the Relative Strength Index (RSI), which measures if a coin is being oversold or overbought. For more information on the RSI, visit: https://www.investopedia.com/terms/r/rsi.asp#:~:text=The%20relative%20strength%20index%20(RSI)%20is%20a%20momentum%20indicator%20used,a%20stock%20or%20other%20asset.&text=An%20RSI%20reading%20of%2030,an%20oversold%20or%20undervalued%20condition." + ] + }, + { + "cell_type": "markdown", + "id": "3d43ff1f", + "metadata": {}, + "source": [ + "#### Why you should use a trading bot?\n", + "Because you won't have to be sitting all day waiting for the market to move. Instead, you can have your bot do that for you. You don't have to miss out again on the next bull market while you're focusing your time on other things.\n", + "\n", + "\n", + "#### Example of use\n", + "If you want to get the current price of Ethereum, alongside a constant update of the price in a graph and how the coin has behaved hourly in the past month in order to take a decision about selling/buying. No worries, just input a couple of things in the GUI, click the associated buttons and there you go - a Warren Buffet on the making. \n" + ] + }, + { + "cell_type": "markdown", + "id": "6d5eaea5", + "metadata": {}, + "source": [ + "## First, let's define the functions" + ] + }, + { + "cell_type": "markdown", + "id": "b85ec6e0", + "metadata": {}, + "source": [ + "This function takes in an argument that could be any real name of a coin. Then, it communicates with the API from CoinMarketCap.com, handles the JSON data and returns the current price in USD of the cryptocurrency. \n", + "\n", + "All functions are called with the ease of a button-click.\n", + "\n", + "Note: In this example, I'm using a fake API_KEY. You should go to the website of CoinMarketCap.com and create your own API key for this to work" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2b48e11c", + "metadata": {}, + "outputs": [], + "source": [ + "def bot_api(coin):\n", + " global data\n", + "\n", + " parameters = {\n", + " 'slug': coin,\n", + " 'convert': \"usd\"\n", + " }\n", + "\n", + " headers = {\n", + " 'Accepts': 'application/json',\n", + " 'X-CMC_PRO_API_KEY': '312456140-af13-4aa0-ad7e-1bdb98b80470'\n", + " }\n", + "\n", + " session = Session()\n", + " session.headers.update(headers)\n", + "\n", + " response = session.get(url, params = parameters)\n", + "\n", + " result = json.loads(response.text)['data']\n", + " result = list(result)\n", + " number = result[0]\n", + " \n", + " result = json.loads(response.text)['data'][str(number)]['quote']['USD']['price']\n", + "\n", + " return(result)" + ] + }, + { + "cell_type": "markdown", + "id": "6fa1a5f0", + "metadata": {}, + "source": [ + "The following function allows the GUI to display the result from the last function. Everytime the button is clicked, the last result is deleted and the current price is shown." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e035ac77", + "metadata": {}, + "outputs": [], + "source": [ + "def crypto_price(coin):\n", + " result = bot_api(coin)\n", + " entry_results.delete(0, END)\n", + " entry_results.insert(0, str(result))" + ] + }, + { + "cell_type": "markdown", + "id": "d258910b", + "metadata": {}, + "source": [ + "The following function takes in the coin name and displays the official logo of your cryptocurrency on the side of the current price as a .png\n", + "\n", + "Note: As of now, it only displays the logo for bitcoin, ethereum, cardano, dogecoin and litecoin. If your favorite crypto coin is not one of the above, no image is shown." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "22d02009", + "metadata": {}, + "outputs": [], + "source": [ + "def add_image(coin):\n", + " global my_image\n", + " initial_coin = coin\n", + " coin_path = 'logos/'\n", + " index = '.png'\n", + " final_coin = coin_path + coin + index\n", + " filepath = final_coin\n", + " my_image = tk.PhotoImage(file=filepath)\n", + " coin_image.delete('1.0', END)\n", + " coin_image.image_create(END, image = my_image)\n" + ] + }, + { + "cell_type": "markdown", + "id": "3316dc4e", + "metadata": {}, + "source": [ + "The following is an asynchronous function that uses a websocket from Binance. It take in the symbol of your favorite cryptocurrency and sends the necessary information to the update_graph() function. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6fa155b9", + "metadata": {}, + "outputs": [], + "source": [ + "async def main(symbol):\n", + " url = \"wss://stream.binance.com:9443/stream?streams=\" + symbol + \"usdt@miniTicker\"\n", + " async with websockets.connect(url) as client:\n", + " while True:\n", + " data = json.loads(await client.recv())['data']\n", + "\n", + " event_time = time.localtime(data['E'] // 1000)\n", + " event_time = f\"{event_time.tm_hour}:{event_time.tm_min}:{event_time.tm_sec}\"\n", + "\n", + " print(event_time, data['c'])\n", + "\n", + " xdata.append(event_time)\n", + " ydata.append(int(float(data['c'])))\n", + "\n", + " update_graph()\n", + " \n", + "def run_bot2(symbol):\n", + " if __name__ == '__main__':\n", + " loop = asyncio.get_event_loop()\n", + " loop.run_until_complete(main(symbol))" + ] + }, + { + "cell_type": "markdown", + "id": "f945dd3c", + "metadata": {}, + "source": [ + "The following functions plot the data provided by the websocket. This allows the user to observe the live behavior of its chosen crypto in a beautiful graph. You can see a graph below as an example." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "934bbca9", + "metadata": {}, + "outputs": [], + "source": [ + "def show_plot():\n", + " global ax\n", + " global fig\n", + "\n", + " fig = plt.figure()\n", + " ax = fig.add_subplot(111)\n", + " fig.show()\n", + "\n", + "def update_graph():\n", + " ax.plot(xdata, ydata, color='g')\n", + " ax.legend([f\"Last price: {ydata[-1]}$\"])\n", + "\n", + " fig.canvas.draw()\n", + " ax.axes.get_xaxis().set_visible(False) \n", + " plt.pause(0.1)" + ] + }, + { + "cell_type": "markdown", + "id": "392a8ad9", + "metadata": {}, + "source": [ + "If the users wants to observe the historical candlestick behavior of a cryptocurrency (graphically), this function is called via a button in the GUI.\n", + "\n", + "The user needs to specify the desired crypto symbol, an interval (1h or 24 h), the starting date and the end date. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e01a3522", + "metadata": {}, + "outputs": [], + "source": [ + "def historical(symbol, interval, start, end):\n", + " global df\n", + "\n", + " url = 'https://api.binance.com/api/v3/klines'\n", + "\n", + " symbol = symbol.upper()\n", + "\n", + " startTime = str(int(dt.datetime(2020,start,1).timestamp() * 1000))\n", + " endTime = str(int(dt.datetime(2020,end,1).timestamp() * 1000))\n", + " limit = '1000'\n", + "\n", + " req_params = {'symbol': symbol + 'USDT', 'interval': interval, 'startTime': startTime, \n", + " 'endTime': endTime, 'limit': limit}\n", + "\n", + " df = pd.DataFrame(json.loads(requests.get(url, params = req_params).text))\n", + "\n", + " df = df.iloc[:, 0:6]\n", + "\n", + " df.columns = ['datetime', 'open', 'high', 'low', 'close', 'volume']\n", + "\n", + " df.index = [dt.datetime.fromtimestamp(x / 1000.0) for x in df.datetime]\n", + "\n", + " df['close'] = df['close'].astype(float)\n", + " df['close'].plot()\n", + " plt.show()\n", + " return df" + ] + }, + { + "cell_type": "markdown", + "id": "606c1025", + "metadata": {}, + "source": [ + "Now, we need to assing some values to the objects" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d957470c", + "metadata": {}, + "outputs": [], + "source": [ + "#This is the url of the CoinMarketCao API - it tells you the latest price\n", + "url = 'https://pro-api.coinmarketcap.com/v1/cryptocurrency/quotes/latest'\n", + "\n", + "#Assing an empty list to the x, y of the live graph\n", + "xdata = []\n", + "ydata = []" + ] + }, + { + "cell_type": "markdown", + "id": "3b1c3b67", + "metadata": {}, + "source": [ + "# GUI" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4a257f8a", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from IPython.display import display, Image\n", + "\n", + "display(Image(filename='/Users/deborastein/Dropbox/Mi Mac (MacBook-Air-de-DEBORA.local)/Desktop/Gui.png'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d3e7cc91", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/LICENSE b/Crypto_bot_pkg/LICENSE similarity index 95% rename from LICENSE rename to Crypto_bot_pkg/LICENSE index 139ea94..9cf1062 100644 --- a/LICENSE +++ b/Crypto_bot_pkg/LICENSE @@ -1,7 +1,5 @@ MIT License -Copyright (c) 2021 Programming-The-Next-Step-2021 - Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights diff --git a/README.md b/Crypto_bot_pkg/README.md similarity index 95% rename from README.md rename to Crypto_bot_pkg/README.md index 9a4e235..5a96137 100644 --- a/README.md +++ b/Crypto_bot_pkg/README.md @@ -8,3 +8,4 @@ The program will display the efficacy of the aforementioned algorithm if it woul TO THE MOON! +branch crypto-selection trial \ No newline at end of file diff --git a/Crypto_bot_pkg/RSI_OVERBOUGHT: b/Crypto_bot_pkg/RSI_OVERBOUGHT: new file mode 100644 index 0000000..e69de29 diff --git a/Crypto_bot_pkg/__init__.py b/Crypto_bot_pkg/__init__.py new file mode 100644 index 0000000..dda691a --- /dev/null +++ b/Crypto_bot_pkg/__init__.py @@ -0,0 +1 @@ +from Crypto_bot_pkg.crypto_selection import crypto_bot diff --git a/Crypto_bot_pkg/__pycache__/__init__.cpython-39.pyc b/Crypto_bot_pkg/__pycache__/__init__.cpython-39.pyc new file mode 100644 index 0000000..e015ba7 Binary files /dev/null and b/Crypto_bot_pkg/__pycache__/__init__.cpython-39.pyc differ diff --git a/Crypto_bot_pkg/__pycache__/config.cpython-39.pyc b/Crypto_bot_pkg/__pycache__/config.cpython-39.pyc new file mode 100644 index 0000000..59d27d6 Binary files /dev/null and b/Crypto_bot_pkg/__pycache__/config.cpython-39.pyc differ diff --git a/Crypto_bot_pkg/__pycache__/crypto_selection.cpython-39.pyc b/Crypto_bot_pkg/__pycache__/crypto_selection.cpython-39.pyc new file mode 100644 index 0000000..221f155 Binary files /dev/null and b/Crypto_bot_pkg/__pycache__/crypto_selection.cpython-39.pyc differ diff --git a/Crypto_bot_pkg/bot.py b/Crypto_bot_pkg/bot.py new file mode 100644 index 0000000..eec2ba9 --- /dev/null +++ b/Crypto_bot_pkg/bot.py @@ -0,0 +1,22 @@ +import websocket + +cc = 'btcusd' +interval = '1m' +SOCKET = f"wss://stream.binance.com:9443/ws/{cc}t@trade" + +def on_message(ws, message): + print("received message") + print(message) + +def on_open(ws): + print('opened connection') + +def on_close(ws): + print('closed connection') + +ws = websocket.WebSocketApp(SOCKET, on_open=on_open, on_message = on_message, on_close = on_close) + +ws.run_forever() + +# ws = websocket.WebSocketApp(SOCKET, on_open=on_open, on_close=on_close, on_message=on_message) +# ws.run_forever() \ No newline at end of file diff --git a/Crypto_bot_pkg/config.py b/Crypto_bot_pkg/config.py new file mode 100644 index 0000000..03c1e4e --- /dev/null +++ b/Crypto_bot_pkg/config.py @@ -0,0 +1,2 @@ +API_KEY = 'yourbinanceapikey' +API_SECRET = 'yourbinanceapisecret' \ No newline at end of file diff --git a/Crypto_bot_pkg/crypto_selection.py b/Crypto_bot_pkg/crypto_selection.py new file mode 100644 index 0000000..8eb3716 --- /dev/null +++ b/Crypto_bot_pkg/crypto_selection.py @@ -0,0 +1,23 @@ +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt + +#This is where I'll code the functions + +class Crypto_bot: + """ + Documentation: A class where you can select your favorite cryptos, track them and use a trading bot + """ + + def which_crypto(): + """ + This is function 1 + """ + print("This function will allow you to choose between BTC, ETH, ADA or DOGE coins") + + def trade_bot(): + """ + This is function 2 + """ + print("This function will suggest you to sell or buy") + diff --git a/Crypto_bot_pkg/requirements.txt b/Crypto_bot_pkg/requirements.txt new file mode 100644 index 0000000..40fd168 --- /dev/null +++ b/Crypto_bot_pkg/requirements.txt @@ -0,0 +1,4 @@ +python-binance +TA-Lib +numpy +websocket diff --git a/Crypto_bot_pkg/setup.py b/Crypto_bot_pkg/setup.py new file mode 100644 index 0000000..0778d23 --- /dev/null +++ b/Crypto_bot_pkg/setup.py @@ -0,0 +1,12 @@ +import setuptools + +# AlexisDaniels: +setuptools.setup( + name = "crypto bot", + version = 0.1, + author = "Alexis", + author_email = "alexis_daniels@hotmail.com", + description = "A package where you can keep track of your favorite cryptocurrencies and obtain buy/sell suggestion based on sentiment analysis of influencers", + license = 'MIT', + packages = setuptools.find_packages() + ) diff --git a/build/lib/Crypto_bot_pkg/__init__.py b/build/lib/Crypto_bot_pkg/__init__.py new file mode 100644 index 0000000..4e551b3 --- /dev/null +++ b/build/lib/Crypto_bot_pkg/__init__.py @@ -0,0 +1,2 @@ +from Crypto_bot_pkg.crypto_selection import which_crypto +from Crypto_bot_pkg.crypto_selection import trade_bot diff --git a/build/lib/Crypto_bot_pkg/crypto_selection.py b/build/lib/Crypto_bot_pkg/crypto_selection.py new file mode 100644 index 0000000..f1e186b --- /dev/null +++ b/build/lib/Crypto_bot_pkg/crypto_selection.py @@ -0,0 +1,17 @@ +class crypto_bot: + """ + A class where you can select your favorite cryptos, track them and use a trading bot + """ + + def which_crypto(): + """ + This is function 1 + """ + print("This function will allow you to choose between BTC, ETH, ADA or DOGE coins") + + def trade_bot(): + """ + This is function 2 + """ + print("This function will suggest you to sell or buy") + diff --git a/build/lib/Crypto_bot_pkg/setup.py b/build/lib/Crypto_bot_pkg/setup.py new file mode 100644 index 0000000..0778d23 --- /dev/null +++ b/build/lib/Crypto_bot_pkg/setup.py @@ -0,0 +1,12 @@ +import setuptools + +# AlexisDaniels: +setuptools.setup( + name = "crypto bot", + version = 0.1, + author = "Alexis", + author_email = "alexis_daniels@hotmail.com", + description = "A package where you can keep track of your favorite cryptocurrencies and obtain buy/sell suggestion based on sentiment analysis of influencers", + license = 'MIT', + packages = setuptools.find_packages() + ) diff --git a/crypto_bot.egg-info/PKG-INFO b/crypto_bot.egg-info/PKG-INFO new file mode 100644 index 0000000..e6a3169 --- /dev/null +++ b/crypto_bot.egg-info/PKG-INFO @@ -0,0 +1,10 @@ +Metadata-Version: 1.0 +Name: crypto-bot +Version: 0.1 +Summary: A package where you can keep track of your favorite cryptocurrencies and obtain buy/sell suggestion based on sentiment analysis of influencers +Home-page: UNKNOWN +Author: Alexis +Author-email: alexis_daniels@hotmail.com +License: MIT +Description: UNKNOWN +Platform: UNKNOWN diff --git a/crypto_bot.egg-info/SOURCES.txt b/crypto_bot.egg-info/SOURCES.txt new file mode 100644 index 0000000..62b2582 --- /dev/null +++ b/crypto_bot.egg-info/SOURCES.txt @@ -0,0 +1,7 @@ +Crypto_bot_pkg/__init__.py +Crypto_bot_pkg/crypto_selection.py +Crypto_bot_pkg/setup.py +crypto_bot.egg-info/PKG-INFO +crypto_bot.egg-info/SOURCES.txt +crypto_bot.egg-info/dependency_links.txt +crypto_bot.egg-info/top_level.txt \ No newline at end of file diff --git a/crypto_bot.egg-info/dependency_links.txt b/crypto_bot.egg-info/dependency_links.txt new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/crypto_bot.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/crypto_bot.egg-info/top_level.txt b/crypto_bot.egg-info/top_level.txt new file mode 100644 index 0000000..3274244 --- /dev/null +++ b/crypto_bot.egg-info/top_level.txt @@ -0,0 +1 @@ +Crypto_bot_pkg diff --git a/dist/crypto_bot-0.1-py3.9.egg b/dist/crypto_bot-0.1-py3.9.egg new file mode 100644 index 0000000..495ad3c Binary files /dev/null and b/dist/crypto_bot-0.1-py3.9.egg differ diff --git a/newfile.txt b/newfile.txt new file mode 100644 index 0000000..e69de29