From a38b33db28ba1ed6d20422dc86fff160a4b06768 Mon Sep 17 00:00:00 2001 From: AlexisDaniels Date: Tue, 11 May 2021 22:02:29 -0500 Subject: [PATCH 1/7] Update README.md --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 9a4e235..ea97dbd 100644 --- a/README.md +++ b/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 \ No newline at end of file From dffe7cd5ffde569d61d1d4a35f4997fe9fcbea59 Mon Sep 17 00:00:00 2001 From: AlexisDaniels Date: Tue, 11 May 2021 22:04:17 -0500 Subject: [PATCH 2/7] Creating a package --- Crypto_bot_pkg/__init__.py | 0 Crypto_bot_pkg/crypto_selection.py | 9 +++++++++ Crypto_bot_pkg/setup.py | 27 +++++++++++++++++++++++++++ 3 files changed, 36 insertions(+) create mode 100644 Crypto_bot_pkg/__init__.py create mode 100644 Crypto_bot_pkg/crypto_selection.py create mode 100644 Crypto_bot_pkg/setup.py diff --git a/Crypto_bot_pkg/__init__.py b/Crypto_bot_pkg/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/Crypto_bot_pkg/crypto_selection.py b/Crypto_bot_pkg/crypto_selection.py new file mode 100644 index 0000000..fd17c31 --- /dev/null +++ b/Crypto_bot_pkg/crypto_selection.py @@ -0,0 +1,9 @@ +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt + +#This is where I'll code the functions + +def which_crypto(): + print("This function will allow you to choose between BTC, ETH, ADA or DOGE coins") + diff --git a/Crypto_bot_pkg/setup.py b/Crypto_bot_pkg/setup.py new file mode 100644 index 0000000..081fb44 --- /dev/null +++ b/Crypto_bot_pkg/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup + +def readme(): + with open('README.md') as f: + return f.read() + + +# AlexisDaniels: +setup(name = "crypto-Alexis", + version = 0.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", + long_description = file: README.md, + long_description_content_type = text/markdown, + keywords = 'crypto', 'algotrade', + license = 'MIT', + url = https://github.com/Programming-The-Next-Step-2021/Weather-app, + classifiers = [ + Programming Language :: Python :: 3, + License :: OSI Approved :: MIT License, + Operating System :: OS Independent, + ] + package_dir = + = src + packages = [packages], + python_requires = >=3.6 \ No newline at end of file From 2561ef7776e0a1add2e7dc61d1c85ba0fa3b7bfe Mon Sep 17 00:00:00 2001 From: AlexisDaniels Date: Tue, 11 May 2021 22:11:54 -0500 Subject: [PATCH 3/7] added new file --- newfile.txt | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 newfile.txt diff --git a/newfile.txt b/newfile.txt new file mode 100644 index 0000000..e69de29 From 95ed4a31a2bf2a2377d9e93a25ed9d6eb8022156 Mon Sep 17 00:00:00 2001 From: AlexisDaniels Date: Tue, 11 May 2021 23:51:29 -0500 Subject: [PATCH 4/7] Added documentation and a class Now I can import the package and use the functions independently --- LICENSE => Crypto_bot_pkg/LICENSE | 2 -- README.md => Crypto_bot_pkg/README.md | 2 +- Crypto_bot_pkg/__init__.py | 4 ++++ .../__pycache__/__init__.cpython-39.pyc | Bin 0 -> 275 bytes .../crypto_selection.cpython-39.pyc | Bin 0 -> 949 bytes Crypto_bot_pkg/crypto_selection.py | 20 ++++++++++++++++++ Crypto_bot_pkg/setup.py | 17 ++++++++++++++- build/lib/Crypto_bot_pkg/__init__.py | 2 ++ build/lib/Crypto_bot_pkg/crypto_selection.py | 17 +++++++++++++++ build/lib/Crypto_bot_pkg/setup.py | 12 +++++++++++ crypto_bot.egg-info/PKG-INFO | 10 +++++++++ crypto_bot.egg-info/SOURCES.txt | 7 ++++++ crypto_bot.egg-info/dependency_links.txt | 1 + crypto_bot.egg-info/top_level.txt | 1 + dist/crypto_bot-0.1-py3.9.egg | Bin 0 -> 3516 bytes 15 files changed, 91 insertions(+), 4 deletions(-) rename LICENSE => Crypto_bot_pkg/LICENSE (95%) rename README.md => Crypto_bot_pkg/README.md (95%) create mode 100644 Crypto_bot_pkg/__pycache__/__init__.cpython-39.pyc create mode 100644 Crypto_bot_pkg/__pycache__/crypto_selection.cpython-39.pyc create mode 100644 build/lib/Crypto_bot_pkg/__init__.py create mode 100644 build/lib/Crypto_bot_pkg/crypto_selection.py create mode 100644 build/lib/Crypto_bot_pkg/setup.py create mode 100644 crypto_bot.egg-info/PKG-INFO create mode 100644 crypto_bot.egg-info/SOURCES.txt create mode 100644 crypto_bot.egg-info/dependency_links.txt create mode 100644 crypto_bot.egg-info/top_level.txt create mode 100644 dist/crypto_bot-0.1-py3.9.egg 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 ea97dbd..5a96137 100644 --- a/README.md +++ b/Crypto_bot_pkg/README.md @@ -8,4 +8,4 @@ The program will display the efficacy of the aforementioned algorithm if it woul TO THE MOON! -branch crypto-selection \ No newline at end of file +branch crypto-selection trial \ No newline at end of file diff --git a/Crypto_bot_pkg/__init__.py b/Crypto_bot_pkg/__init__.py index e69de29..d6a3fa6 100644 --- a/Crypto_bot_pkg/__init__.py +++ b/Crypto_bot_pkg/__init__.py @@ -0,0 +1,4 @@ +<<<<<<< Updated upstream +======= +from Crypto_bot_pkg.crypto_selection import crypto_bot +>>>>>>> Stashed changes 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 0000000000000000000000000000000000000000..e015ba7ef7dca65f17329428c2a879eb531f11c3 GIT binary patch literal 275 zcmYe~<>g`kg5$BX6U>41V-N=!FabFZKwK;UBvKes7;_kM8KW2(8B&;n88n$+0!0}# z8Et4u$% zIJKx)KP5FOzbLV|BsDWn-=!$OASu5>-#1giH!)d314uaK=V$9WW)|tDr0Tl3I{61V z>gD7oC+2ACyW}UA=BDPA6zjWZmUxsV=|h~L>y%#tWr7?Ba*cj`d}dx|NqoFsLFFwD To80`A(wtN~MxawZ12F>toKa3; literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..221f1554b8842d3dc00b11f8704abf6f1c79c18a GIT binary patch literal 949 zcmb_by^a$x5cVdUAEI1?kZ7l%AX1VQ)CgVvloQhBBnVA}WW2U7v2L>twwI6;G~8S8 z1os|10p+$l0v#3OO~?f)bc}Y!_Wao2eD<=lvj#!={_gAhZvi1c{Nh;3xHw0(57CT? zAR@R${Zg6{QF=pKWsd&8q=c(;R10V%nFWH(N+Ot*MM;!z$t)D1sNh%;RjjY&4Q@6o zr)jL+Hf{h)4|u|?h4n%j2^*aOXDL{jNbda7z%~1*jdBupwYCk;Fn$AWA(y~X0hyJ+ zyi=%j4!E`7x7hq7-hs#4MB{vKL9p*_`=luGwbO;NfZuhNa;J0(&kmvOt0H)atW}Z# zOA@^RtG(iXE^F#z3z1r%~{flhMH$f znK~PdmAlB|Xi$*e>1(&2dj9F^W*+UYV@Ef3+Ffn(=6a#{g6=|9PnN%B5^f*wv$42) zob$g}etyq#=LE|(o6n^!9t9xJh&l0m#@S|KJi>blce4um@(2D|NZ+r&@jsnBI_l(* zFlkluI;AOFN=owvrAsZc#Lt_Qe#ls|kJKm?np0{#H>UQFlMVi0#H;mb^&kxE)xtMv T1;uz0ZvDmX(3igQCo1_3uLJM8 literal 0 HcmV?d00001 diff --git a/Crypto_bot_pkg/crypto_selection.py b/Crypto_bot_pkg/crypto_selection.py index fd17c31..99a59c3 100644 --- a/Crypto_bot_pkg/crypto_selection.py +++ b/Crypto_bot_pkg/crypto_selection.py @@ -1,3 +1,4 @@ +<<<<<<< Updated upstream import numpy as np import pandas as pd import matplotlib.pyplot as plt @@ -7,3 +8,22 @@ def which_crypto(): print("This function will allow you to choose between BTC, ETH, ADA or DOGE coins") +======= +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") + +>>>>>>> Stashed changes diff --git a/Crypto_bot_pkg/setup.py b/Crypto_bot_pkg/setup.py index 081fb44..a42e4c2 100644 --- a/Crypto_bot_pkg/setup.py +++ b/Crypto_bot_pkg/setup.py @@ -1,3 +1,4 @@ +<<<<<<< Updated upstream from setuptools import setup def readme(): @@ -24,4 +25,18 @@ def readme(): package_dir = = src packages = [packages], - python_requires = >=3.6 \ No newline at end of file + python_requires = >=3.6 +======= +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() + ) +>>>>>>> Stashed changes 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 0000000000000000000000000000000000000000..495ad3cc1d87da41c6bf2d47df7458e81472b498 GIT binary patch literal 3516 zcma)82{@E{7k}-IrTFYo$x>(->qU2LO-xLdMiVLqV?xFlX6#FG!xbTv!iQ>d8CzMR zYd2(>EK#B;g*z81TU>5m?(6n+jnVD-{_~vYo%ea(^E>DHo%1{YV~gVA76Sla2asP= zgnn_g{<9JI<_p?x&=CG1B#JNA&6k2Dd3(UHSTCX%1&dWDg`f^~^P+E(NVp?Q@g#=5nE^Vze?YH~O&w43(LRBn}TksUVl>33wdE%a;g7zmj6?P1g`^TM54$moHUUiPNiwbPu+L zrA$_+(Wav*rSsLv6I6MGiXr#fO7MpukL)Co1I3bW$n6W|2-Uk!ALwbkT-Q1wR}80n zCLc>mobYbSYcz1URcltf-!#jn<0!VTpOeU6D+i zf<}#yk^?NPsxX0azsK~)cE(_=#^cuPp~I;$9phCIMScVu-An}6 zPW|w@eXc`m1+=$L!DK`_-?Hxz6X`g=CZpdoe(XeK%D|YD`OI$^Oq*K}&n7?SAU|2_ z*NxUdUao=sNN(qcjHd*UKvJwyG`(9j1Y=e{@n78;#D{!Q8gpb9ajLH*%vM%OgxS$t zUe?`MHcPGCn;7zXAPt%$$>dUwso`c8AHf(lwe{=Gh{tqJqdp?D7T~8+lE#kD@mI}z zNB2Fn%@wFgvky!ivRe#~z3nQPwm95?|1fAp^fG@S?H1+J7!a9twu7okd?gTy9uI+> ziHwNi=@vppm&L=Ir{$%@YDCn8!`;SWi$kU6-oyE#eVj$>4{9FgS2nCsmlL4)MVu^` z&`DD8@*22>);e}Nl{;tPnrdHZS0>$&SH=##wq$e%kGLJ87ni)!OF!_Qd>*}CLUx&Y ziKW2BnT2Z{n{>H@bV-^b-ZX&piZ! zF6#_V_yw+@ZJ=QEu%J9oabE}X?~cC$>SKPuJt;MaH{qw6d7j~^P+|OhTcJT=r_#;U z5HmTMgd0(5!Y3XH6+oR9{lRFeF#YRX6V&U*4*gN4|0C4#GglyB= zR$@x*7)b*fVgdb2rq71u6dwdN=cD%t9#KdUzD=Q-Lc5|%RTamFa$0xmsXsvEk7`|L zmVA6+jt5#XDLQn&#d@FJm9C_sk(t(&H{>L7fB$~-p2*0x&#TCbeK1Pz`JUJMdb^xz zOa$+bJzA|MB{}>d65zcQiL99cB=s}-1iKLukG-MpRWdrs4z1I~l8V?F-|Id!dsGpr z_}yXRPZc7z7Ku^vlbLkONfQg+Sd?|i`cslcgQ^-d&Z=xG>e(gdD63V@V~^zYWPg6` zE{|%uvP>>|gPcz?e3c|HNEV1ztNxfqYkLV5=N%#6^mxjDt$E6*DiW)-a`VVB$Wcqo z$)OU?Ow~!CZA2p5V=nNA_s#ChrF?f5MU;h@`_vDZTyYN=+*)fieML-t;Q= z#JJOMKyZ8lN3K15pKG+I?j5#KpYG8c2e*hFuTKmPxh7amBc3GR<7HrmRnVq(br!mC z51YMaGwne^8v4bnSU1C3(V`1Sp=k#pdVvQs=+JtoUqj|J>0pa#L9MOPTs6aRqK6|5 z$#;C2XMlKz;F^7vr@e-NtFwh>e6Ig#J|nxsCqG`(P7F6&^`!ekcJb(i=sFqfAph-x zX9dgoqj{&3TYTzY$gaJx|FrC~&bd`hPi2)Weg>O|n-c(F-*28TgJ^5VIGw0Z64ex5 zKJbvBF3fMKnvwCgT<(^r9Cy&|+ZTCNFI5K5c0OwLE`u*$?f%gO$)RIwJEAbBN-PZK zF1Rtu1<@P~$6fJgSiSE6{Vj1~hGA3o$|EttW4&|#l#0q;5#@X>y0eB$nYJz(r+b3$ zJk8%F7m2-*S>LUFIr!1_IODaEU;cc!{`7z%g#-f7M{Z*i^IV<78q2t8SFhgttnHc~?IvzLw&}=Ex z5rY}Qn0hjbhQxO~A|(b0NmVN3n&bft5kj932Y$!Etw%X$UslDpa_=4ZqjQ|efLj%N z%1tsS6pTh_|Bgw_2 z&Gx^G96zZuCpWV`cet4V?=)Y}p6Y$QwWy2(9|0yo7=!_QD6R; zrC3?hO~AW^%#W43J9^GcNkY!k9rrtNaq&vRWg zcXUJx)OHUBNEPzrW(-rO+D39~N8gQ*<3$$xTlSt?I+(qqAt@aqp)#h~9Pi1?c*Z4d zuS@?qH+A@T&W}nSmN^z213t6Czp(3FtXRKMc8L>GtjfEe;_ zL?Jb^chr)4uGH^z@a+5A_LZL5ggr{nsZkA%Fdu}7LFGk{d0bPg*wUKvgJ~Jq6T^GI zP{k=VVSaj4qeTLf?^9|n=L=`d|nS(@K&qWx>Do>!-4wN)1qW%(7~Dy{Fa z68leshEF@+)(q2lpKF0b901D(>|xE&9Z$j&-SI?R2$tYQ^d@hlI?lRhZCs4mks1Hn zsP-<&7NX8#prA zK>m;AgB_p!_TI!F1Y6-d_}d8BI+@wyun+ppIHJ7Yjq|Os&koK$a5lkz=VKAt*YU&d z&aTW&_s=_6+*x$Wj= Date: Mon, 17 May 2021 10:36:16 -0500 Subject: [PATCH 5/7] add your personal API address here --- Crypto_bot_pkg/config.py | 0 Crypto_bot_pkg/requirements.txt | 0 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 Crypto_bot_pkg/config.py create mode 100644 Crypto_bot_pkg/requirements.txt diff --git a/Crypto_bot_pkg/config.py b/Crypto_bot_pkg/config.py new file mode 100644 index 0000000..e69de29 diff --git a/Crypto_bot_pkg/requirements.txt b/Crypto_bot_pkg/requirements.txt new file mode 100644 index 0000000..e69de29 From 8768fc73e0fe93a8da879683d2356f11aa4dcabb Mon Sep 17 00:00:00 2001 From: AlexisDaniels Date: Mon, 17 May 2021 13:07:50 -0500 Subject: [PATCH 6/7] Installed SSL certificates - get inifinite messages --- .vscode/settings.json | 3 ++ Crypto_bot_pkg/RSI_OVERBOUGHT: | 0 Crypto_bot_pkg/__init__.py | 3 -- .../__pycache__/config.cpython-39.pyc | Bin 0 -> 212 bytes Crypto_bot_pkg/bot.py | 22 +++++++++++++ Crypto_bot_pkg/config.py | 2 ++ Crypto_bot_pkg/crypto_selection.py | 8 +---- Crypto_bot_pkg/requirements.txt | 4 +++ Crypto_bot_pkg/setup.py | 30 ------------------ 9 files changed, 32 insertions(+), 40 deletions(-) create mode 100644 .vscode/settings.json create mode 100644 Crypto_bot_pkg/RSI_OVERBOUGHT: create mode 100644 Crypto_bot_pkg/__pycache__/config.cpython-39.pyc create mode 100644 Crypto_bot_pkg/bot.py 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_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 index d6a3fa6..dda691a 100644 --- a/Crypto_bot_pkg/__init__.py +++ b/Crypto_bot_pkg/__init__.py @@ -1,4 +1 @@ -<<<<<<< Updated upstream -======= from Crypto_bot_pkg.crypto_selection import crypto_bot ->>>>>>> Stashed changes 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 0000000000000000000000000000000000000000..59d27d6dbb4aaef14a2a6b6f846d3df7a9a754b7 GIT binary patch literal 212 zcmYe~<>g`k0?VF72_X70h(HF6K#l_t7qb9~6oz01O-8?!3`HPe1o5jnze3+PQ^7YeSwRCxIOXSO>pEr@>87OWy0|*|2RZ8HTQ zXzIJ97H5~_7w9|sxJGye>pK@!7L?>esd%US5*RZnza+jOJ6%6HKQApaU9X_>7Kcr4 QeoARhsvXElpMjVG07=?7cK`qY literal 0 HcmV?d00001 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 index e69de29..03c1e4e 100644 --- a/Crypto_bot_pkg/config.py +++ 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 index 99a59c3..8eb3716 100644 --- a/Crypto_bot_pkg/crypto_selection.py +++ b/Crypto_bot_pkg/crypto_selection.py @@ -1,15 +1,10 @@ -<<<<<<< Updated upstream import numpy as np import pandas as pd import matplotlib.pyplot as plt #This is where I'll code the functions -def which_crypto(): - print("This function will allow you to choose between BTC, ETH, ADA or DOGE coins") - -======= -class crypto_bot: +class Crypto_bot: """ Documentation: A class where you can select your favorite cryptos, track them and use a trading bot """ @@ -26,4 +21,3 @@ def trade_bot(): """ print("This function will suggest you to sell or buy") ->>>>>>> Stashed changes diff --git a/Crypto_bot_pkg/requirements.txt b/Crypto_bot_pkg/requirements.txt index e69de29..40fd168 100644 --- a/Crypto_bot_pkg/requirements.txt +++ 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 index a42e4c2..0778d23 100644 --- a/Crypto_bot_pkg/setup.py +++ b/Crypto_bot_pkg/setup.py @@ -1,32 +1,3 @@ -<<<<<<< Updated upstream -from setuptools import setup - -def readme(): - with open('README.md') as f: - return f.read() - - -# AlexisDaniels: -setup(name = "crypto-Alexis", - version = 0.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", - long_description = file: README.md, - long_description_content_type = text/markdown, - keywords = 'crypto', 'algotrade', - license = 'MIT', - url = https://github.com/Programming-The-Next-Step-2021/Weather-app, - classifiers = [ - Programming Language :: Python :: 3, - License :: OSI Approved :: MIT License, - Operating System :: OS Independent, - ] - package_dir = - = src - packages = [packages], - python_requires = >=3.6 -======= import setuptools # AlexisDaniels: @@ -39,4 +10,3 @@ def readme(): license = 'MIT', packages = setuptools.find_packages() ) ->>>>>>> Stashed changes From 9de2c29b8aec5575e23a51f4d3366a37d6c3e46b Mon Sep 17 00:00:00 2001 From: AlexisDaniels <78614328+AlexisDaniels@users.noreply.github.com> Date: Tue, 25 May 2021 20:14:30 -0500 Subject: [PATCH 7/7] Vignette for the crypto_bot package This vignette was created using Jupyter notebooks. It contains information about how to use the GUI and some details about the RSI. --- Crypto Bot Vignette.ipynb | 349 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 349 insertions(+) create mode 100644 Crypto Bot Vignette.ipynb 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 +}