├── .gitignore ├── LICENSE ├── README.md ├── candlestick ├── __init__.py ├── candlestick.py └── patterns │ ├── bearish_engulfing.py │ ├── bearish_harami.py │ ├── bullish_engulfing.py │ ├── bullish_harami.py │ ├── candlestick_finder.py │ ├── dark_cloud_cover.py │ ├── doji.py │ ├── doji_star.py │ ├── dragonfly_doji.py │ ├── evening_star.py │ ├── evening_star_doji.py │ ├── gravestone_doji.py │ ├── hammer.py │ ├── hanging_man.py │ ├── inverted_hammer.py │ ├── morning_star.py │ ├── morning_star_doji.py │ ├── piercing_pattern.py │ ├── rain_drop.py │ ├── rain_drop_doji.py │ ├── shooting_star.py │ └── star.py └── sample └── binance_sample.py /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | *.egg-info/ 24 | .installed.cfg 25 | *.egg 26 | MANIFEST 27 | 28 | # PyInstaller 29 | # Usually these files are written by a python script from a template 30 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 31 | *.manifest 32 | *.spec 33 | 34 | # Installer logs 35 | pip-log.txt 36 | pip-delete-this-directory.txt 37 | 38 | # Unit test / coverage reports 39 | htmlcov/ 40 | .tox/ 41 | .coverage 42 | .coverage.* 43 | .cache 44 | nosetests.xml 45 | coverage.xml 46 | *.cover 47 | .hypothesis/ 48 | .pytest_cache/ 49 | 50 | # Translations 51 | *.mo 52 | *.pot 53 | 54 | # Django stuff: 55 | *.log 56 | local_settings.py 57 | db.sqlite3 58 | 59 | # Flask stuff: 60 | instance/ 61 | .webassets-cache 62 | 63 | # Scrapy stuff: 64 | .scrapy 65 | 66 | # Sphinx documentation 67 | docs/_build/ 68 | 69 | # PyBuilder 70 | target/ 71 | 72 | # Jupyter Notebook 73 | .ipynb_checkpoints 74 | 75 | # pyenv 76 | .python-version 77 | 78 | # celery beat schedule file 79 | celerybeat-schedule 80 | 81 | # SageMath parsed files 82 | *.sage.py 83 | 84 | # Environments 85 | .env 86 | .venv 87 | env/ 88 | venv/ 89 | ENV/ 90 | env.bak/ 91 | venv.bak/ 92 | 93 | # Spyder project settings 94 | .spyderproject 95 | .spyproject 96 | 97 | # Rope project settings 98 | .ropeproject 99 | 100 | # mkdocs documentation 101 | /site 102 | 103 | # mypy 104 | .mypy_cache/ 105 | 106 | # Created by https://www.gitignore.io/api/pycharm+iml 107 | # Edit at https://www.gitignore.io/?templates=pycharm+iml 108 | 109 | ### PyCharm+iml ### 110 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm 111 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 112 | 113 | # User-specific stuff 114 | .idea/**/workspace.xml 115 | .idea/**/tasks.xml 116 | .idea/**/usage.statistics.xml 117 | .idea/**/dictionaries 118 | .idea/**/shelf 119 | 120 | # Generated files 121 | .idea/**/contentModel.xml 122 | 123 | # Sensitive or high-churn files 124 | .idea/**/dataSources/ 125 | .idea/**/dataSources.ids 126 | .idea/**/dataSources.local.xml 127 | .idea/**/sqlDataSources.xml 128 | .idea/**/dynamic.xml 129 | .idea/**/uiDesigner.xml 130 | .idea/**/dbnavigator.xml 131 | 132 | # Gradle 133 | .idea/**/gradle.xml 134 | .idea/**/libraries 135 | 136 | # Gradle and Maven with auto-import 137 | # When using Gradle or Maven with auto-import, you should exclude module files, 138 | # since they will be recreated, and may cause churn. Uncomment if using 139 | # auto-import. 140 | # .idea/modules.xml 141 | # .idea/*.iml 142 | # .idea/modules 143 | 144 | # CMake 145 | cmake-build-*/ 146 | 147 | # Mongo Explorer plugin 148 | .idea/**/mongoSettings.xml 149 | 150 | # File-based project format 151 | *.iws 152 | 153 | # IntelliJ 154 | out/ 155 | 156 | # mpeltonen/sbt-idea plugin 157 | .idea_modules/ 158 | 159 | # JIRA plugin 160 | atlassian-ide-plugin.xml 161 | 162 | # Cursive Clojure plugin 163 | .idea/replstate.xml 164 | 165 | # Crashlytics plugin (for Android Studio and IntelliJ) 166 | com_crashlytics_export_strings.xml 167 | crashlytics.properties 168 | crashlytics-build.properties 169 | fabric.properties 170 | 171 | # Editor-based Rest Client 172 | .idea/httpRequests 173 | 174 | # Android studio 3.1+ serialized cache file 175 | .idea/caches/build_file_checksums.ser 176 | 177 | ### PyCharm+iml Patch ### 178 | # Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023 179 | 180 | *.iml 181 | modules.xml 182 | .idea/misc.xml 183 | *.ipr 184 | 185 | # End of https://www.gitignore.io/api/pycharm+iml 186 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 DataSmoother 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # candlestick-patterns 2 | > Candlestick patterns detector 3 | 4 | ## Available patterns 5 | * Inverted Hammer 6 | * Hammer 7 | * Hanging man 8 | * Bearish/Bullish Harami 9 | * Dark cloud cover 10 | * Doji 11 | * Doji Star 12 | * Dragonfly doji 13 | * Gravestone doji 14 | * Bearish engulfing 15 | * Bullish engulfing 16 | * Morning star 17 | * Morning star doji 18 | * Piercing pattern 19 | * Rain drop 20 | * Rain drop doji 21 | * Star 22 | * Shooting star 23 | 24 | 25 | ## How to use 26 | ### Dataframe requirements 27 | 28 | - Dataframe must contain open, high, low and close prices 29 | - Open, high, low and close prices must be in numeric type. 30 | 31 | #### Dataframe Example: 32 | 33 | | time | open | high | low | close | 34 | |--------------------:|---------:|---------:|---------:|---------:| 35 | | 2019-12-24 00:00:00 | 7317.3 | 7436.68 | 7157.04 | 7255.77 | 36 | | 2019-12-25 00:00:00 | 7255.77 | 7271.77 | 7128.86 | 7204.63 | 37 | | 2019-12-26 00:00:00 | 7205.01 | 7435 | 7157.12 | 7202 | 38 | | 2019-12-27 00:00:00 | 7202 | 7275.86 | 7076.42 | 7254.74 | 39 | | 2019-12-28 00:00:00 | 7254.77 | 7365.01 | 7238.67 | 7316.14 | 40 | | 2019-12-29 00:00:00 | 7315.36 | 7528.45 | 7288 | 7388.24 | 41 | 42 | ### Code 43 | ```python 44 | from candlestick import candlestick 45 | df = candlestick.inverted_hammer(df, target='result') 46 | ``` 47 | ### Result 48 | 49 | | T | result | open | high | low | close | 50 | |:--------------------|:------------------|---------:|---------:|---------:|---------:| 51 | | 2019-12-24 00:00:00 | False | 7317.3 | 7436.68 | 7157.04 | 7255.77 | 52 | | 2019-12-25 00:00:00 | False | 7255.77 | 7271.77 | 7128.86 | 7204.63 | 53 | | 2019-12-26 00:00:00 | True | 7205.01 | 7435 | 7157.12 | 7202 | 54 | | 2019-12-27 00:00:00 | False | 7202 | 7275.86 | 7076.42 | 7254.74 | 55 | | 2019-12-28 00:00:00 | False | 7254.77 | 7365.01 | 7238.67 | 7316.14 | 56 | | 2019-12-29 00:00:00 | False | 7315.36 | 7528.45 | 7288 | 7388.24 | 57 | 58 | "True" indicates that pattern is detected at that candle 59 | 60 | ## Parametrs 61 | All pattern detection methods receive 3 parametrs: 62 | * target (String) - Indicates the column to which the result of detection is saved as boolean. 63 | * is_reversed (Bool) - Pass True if rows in dataframe are in time descending order, otherwise False. Deafult is False. 64 | * ohlc (List) - Pass list of strings which indicates the column names of open/high/low/close prices in dataframe. Default: ["open", "high", "low", "close"]. 65 | 66 | 67 | ## Support 68 | 69 | If this project helped you in any way and you feel like buying a cup of coffee :coffee:: 70 | 71 | * **BTC:** 1PUGs6mxcW2W3SJi95aG8GvRQRJsoFHWWQ 72 | 73 | * **ETH:** 0x66615e09f7f46429e7620ffbf78479879bbab41d 74 | 75 | * **LTC:** LRxYMgEXMumwxYdimZo9EJ5CfBcipD5c3n 76 | 77 | 78 | -------------------------------------------------------------------------------- /candlestick/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SpiralDevelopment/candlestick-patterns/bd7630a4695c11c9db94351297e5f5384cd0872a/candlestick/__init__.py -------------------------------------------------------------------------------- /candlestick/candlestick.py: -------------------------------------------------------------------------------- 1 | import re 2 | 3 | __builders = dict() 4 | __default_ohlc = ['open', 'high', 'low', 'close'] 5 | 6 | 7 | def __get_file_name(class_name): 8 | res = re.findall('[A-Z][^A-Z]*', class_name) 9 | return '_'.join([cur.lower() for cur in res]) 10 | 11 | 12 | def __load_module(module_path): 13 | p = module_path.rfind('.') + 1 14 | super_module = module_path[p:] 15 | try: 16 | module = __import__(module_path, fromlist=[super_module], level=0) 17 | return module 18 | except ImportError as e: 19 | raise e 20 | 21 | 22 | def __get_class_by_name(class_name): 23 | file_name = __get_file_name(class_name) 24 | mod_name = 'candlestick.patterns.' + file_name 25 | 26 | if mod_name not in __builders: 27 | module = __load_module(mod_name) 28 | __builders[mod_name] = module 29 | else: 30 | module = __builders[mod_name] 31 | return getattr(module, class_name) 32 | 33 | 34 | def __create_object(class_name, target): 35 | return __get_class_by_name(class_name)(target=target) 36 | 37 | 38 | def bullish_hanging_man(candles_df, 39 | ohlc=__default_ohlc, 40 | is_reversed=False, 41 | target=None): 42 | bullhm = __create_object('BullishHangingMan', target) 43 | return bullhm.has_pattern(candles_df, ohlc, is_reversed) 44 | 45 | 46 | def hanging_man(candles_df, 47 | ohlc=__default_ohlc, 48 | is_reversed=False, 49 | target=None): 50 | bearhm = __create_object('HangingMan', target) 51 | return bearhm.has_pattern(candles_df, ohlc, is_reversed) 52 | 53 | 54 | def bearish_harami(candles_df, 55 | ohlc=__default_ohlc, 56 | is_reversed=False, 57 | target=None): 58 | bear_harami = __create_object('BearishHarami', target) 59 | return bear_harami.has_pattern(candles_df, ohlc, is_reversed) 60 | 61 | 62 | def bullish_harami(candles_df, 63 | ohlc=__default_ohlc, 64 | is_reversed=False, 65 | target=None): 66 | bull_harami = __create_object('BullishHarami', target) 67 | return bull_harami.has_pattern(candles_df, ohlc, is_reversed) 68 | 69 | 70 | def gravestone_doji(candles_df, 71 | ohlc=__default_ohlc, 72 | is_reversed=False, 73 | target=None): 74 | gs_doji = __create_object('GravestoneDoji', target) 75 | return gs_doji.has_pattern(candles_df, ohlc, is_reversed) 76 | 77 | 78 | def dark_cloud_cover(candles_df, 79 | ohlc=__default_ohlc, 80 | is_reversed=False, 81 | target=None): 82 | dcc = __create_object('DarkCloudCover', target) 83 | return dcc.has_pattern(candles_df, ohlc, is_reversed) 84 | 85 | 86 | def doji(candles_df, 87 | ohlc=__default_ohlc, 88 | is_reversed=False, 89 | target=None): 90 | doji = __create_object('Doji', target) 91 | return doji.has_pattern(candles_df, ohlc, is_reversed) 92 | 93 | 94 | def doji_star(candles_df, 95 | ohlc=__default_ohlc, 96 | is_reversed=False, 97 | target=None): 98 | doji = __create_object('DojiStar', target) 99 | return doji.has_pattern(candles_df, ohlc, is_reversed) 100 | 101 | 102 | def dragonfly_doji(candles_df, 103 | ohlc=__default_ohlc, 104 | is_reversed=False, 105 | target=None): 106 | doji = __create_object('DragonflyDoji', target) 107 | return doji.has_pattern(candles_df, ohlc, is_reversed) 108 | 109 | 110 | def bearish_engulfing(candles_df, 111 | ohlc=__default_ohlc, 112 | is_reversed=False, 113 | target=None): 114 | cndl = __create_object('BearishEngulfing', target) 115 | return cndl.has_pattern(candles_df, ohlc, is_reversed) 116 | 117 | 118 | def bullish_engulfing(candles_df, 119 | ohlc=__default_ohlc, 120 | is_reversed=False, 121 | target=None): 122 | cndl = __create_object('BullishEngulfing', target) 123 | return cndl.has_pattern(candles_df, ohlc, is_reversed) 124 | 125 | 126 | def hammer(candles_df, 127 | ohlc=__default_ohlc, 128 | is_reversed=False, 129 | target=None): 130 | cndl = __create_object('Hammer', target) 131 | return cndl.has_pattern(candles_df, ohlc, is_reversed) 132 | 133 | 134 | def inverted_hammer(candles_df, 135 | ohlc=__default_ohlc, 136 | is_reversed=False, 137 | target=None): 138 | cndl = __create_object('InvertedHammer', target) 139 | return cndl.has_pattern(candles_df, ohlc, is_reversed) 140 | 141 | 142 | def morning_star(candles_df, 143 | ohlc=__default_ohlc, 144 | is_reversed=False, 145 | target=None): 146 | cndl = __create_object('MorningStar', target) 147 | return cndl.has_pattern(candles_df, ohlc, is_reversed) 148 | 149 | 150 | def morning_star_doji(candles_df, 151 | ohlc=__default_ohlc, 152 | is_reversed=False, 153 | target=None): 154 | cndl = __create_object('MorningStarDoji', target) 155 | return cndl.has_pattern(candles_df, ohlc, is_reversed) 156 | 157 | 158 | def piercing_pattern(candles_df, 159 | ohlc=__default_ohlc, 160 | is_reversed=False, 161 | target=None): 162 | cndl = __create_object('PiercingPattern', target) 163 | return cndl.has_pattern(candles_df, ohlc, is_reversed) 164 | 165 | 166 | def rain_drop(candles_df, 167 | ohlc=__default_ohlc, 168 | is_reversed=False, 169 | target=None): 170 | cndl = __create_object('RainDrop', target) 171 | return cndl.has_pattern(candles_df, ohlc, is_reversed) 172 | 173 | 174 | def rain_drop_doji(candles_df, 175 | ohlc=__default_ohlc, 176 | is_reversed=False, 177 | target=None): 178 | cndl = __create_object('RainDropDoji', target) 179 | return cndl.has_pattern(candles_df, ohlc, is_reversed) 180 | 181 | 182 | def star(candles_df, 183 | ohlc=__default_ohlc, 184 | is_reversed=False, 185 | target=None): 186 | cndl = __create_object('Star', target) 187 | return cndl.has_pattern(candles_df, ohlc, is_reversed) 188 | 189 | 190 | def shooting_star(candles_df, 191 | ohlc=__default_ohlc, 192 | is_reversed=False, 193 | target=None): 194 | cndl = __create_object('ShootingStar', target) 195 | return cndl.has_pattern(candles_df, ohlc, is_reversed) 196 | -------------------------------------------------------------------------------- /candlestick/patterns/bearish_engulfing.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class BearishEngulfing(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 2, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | prev_candle = self.data.iloc[idx + 1 * self.multi_coeff] 11 | 12 | close = candle[self.close_column] 13 | open = candle[self.open_column] 14 | high = candle[self.high_column] 15 | low = candle[self.low_column] 16 | 17 | prev_close = prev_candle[self.close_column] 18 | prev_open = prev_candle[self.open_column] 19 | prev_high = prev_candle[self.high_column] 20 | prev_low = prev_candle[self.low_column] 21 | 22 | return (open >= prev_close > prev_open and 23 | open > close and 24 | prev_open >= close and 25 | open - close > prev_close - prev_open) 26 | 27 | # return (prev_close > prev_open and 28 | # 0.3 > abs(prev_close - prev_open) / (prev_high - prev_low) >= 0.1 and 29 | # close < open and 30 | # abs(close - open) / (high - low) >= 0.7 and 31 | # prev_high < open and 32 | # prev_low > close) 33 | -------------------------------------------------------------------------------- /candlestick/patterns/bearish_harami.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class BearishHarami(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 2, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | prev_candle = self.data.iloc[idx + 1 * self.multi_coeff] 11 | 12 | close = candle[self.close_column] 13 | open = candle[self.open_column] 14 | high = candle[self.high_column] 15 | low = candle[self.low_column] 16 | 17 | prev_close = prev_candle[self.close_column] 18 | prev_open = prev_candle[self.open_column] 19 | prev_high = prev_candle[self.high_column] 20 | prev_low = prev_candle[self.low_column] 21 | 22 | # return (prev_close > prev_open and 23 | # abs(prev_close - prev_open) / (prev_high - prev_low) >= 0.7 and 24 | # 0.3 > abs(close - open) / (high - low) >= 0.1 and 25 | # high < prev_close and 26 | # low > prev_open) 27 | 28 | return (prev_close > prev_open and 29 | prev_open <= close < open <= prev_close and 30 | open - close < prev_close - prev_open) -------------------------------------------------------------------------------- /candlestick/patterns/bullish_engulfing.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class BullishEngulfing(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 2, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | prev_candle = self.data.iloc[idx + 1 * self.multi_coeff] 11 | 12 | close = candle[self.close_column] 13 | open = candle[self.open_column] 14 | high = candle[self.high_column] 15 | low = candle[self.low_column] 16 | 17 | prev_close = prev_candle[self.close_column] 18 | prev_open = prev_candle[self.open_column] 19 | prev_high = prev_candle[self.high_column] 20 | prev_low = prev_candle[self.low_column] 21 | 22 | # return (prev_close < prev_open and 23 | # 0.3 > abs(prev_close - prev_open) / (prev_high - prev_low) >= 0.1 and 24 | # close > open and 25 | # abs(close - open) / (high - low) >= 0.7 and 26 | # prev_high < close and 27 | # prev_low > open) 28 | 29 | return (close >= prev_open > prev_close and 30 | close > open and 31 | prev_close >= open and 32 | close - open > prev_open - prev_close) 33 | -------------------------------------------------------------------------------- /candlestick/patterns/bullish_harami.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class BullishHarami(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 2, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | prev_candle = self.data.iloc[idx + 1 * self.multi_coeff] 11 | 12 | close = candle[self.close_column] 13 | open = candle[self.open_column] 14 | high = candle[self.high_column] 15 | low = candle[self.low_column] 16 | 17 | prev_close = prev_candle[self.close_column] 18 | prev_open = prev_candle[self.open_column] 19 | prev_high = prev_candle[self.high_column] 20 | prev_low = prev_candle[self.low_column] 21 | 22 | # return (prev_close < prev_open and 23 | # abs(prev_close - prev_open) / (prev_high - prev_low) >= 0.7 24 | # and 0.3 > abs(close - open) / (high - low) >= 0.1 25 | # and high < prev_open 26 | # and low > prev_close) 27 | 28 | return (prev_open > prev_close and 29 | prev_close <= open < close <= prev_open and 30 | close - open < prev_open - prev_close) 31 | -------------------------------------------------------------------------------- /candlestick/patterns/candlestick_finder.py: -------------------------------------------------------------------------------- 1 | import pandas as pd 2 | from pandas.api.types import is_numeric_dtype 3 | 4 | 5 | class CandlestickFinder(object): 6 | def __init__(self, name, required_count, target=None): 7 | self.name = name 8 | self.required_count = required_count 9 | self.close_column = 'close' 10 | self.open_column = 'open' 11 | self.low_column = 'low' 12 | self.high_column = 'high' 13 | self.data = None 14 | self.is_data_prepared = False 15 | self.multi_coeff = -1 16 | 17 | if target: 18 | self.target = target 19 | else: 20 | self.target = self.name 21 | 22 | def get_class_name(self): 23 | return self.__class__.__name__ 24 | 25 | def logic(self, row_idx): 26 | raise Exception('Implement the logic of ' + self.get_class_name()) 27 | 28 | def has_pattern(self, 29 | candles_df, 30 | ohlc, 31 | is_reversed): 32 | self.prepare_data(candles_df, 33 | ohlc) 34 | 35 | if self.is_data_prepared: 36 | results = [] 37 | rows_len = len(candles_df) 38 | idxs = candles_df.index.values 39 | 40 | if is_reversed: 41 | self.multi_coeff = 1 42 | 43 | for row_idx in range(rows_len - 1, -1, -1): 44 | 45 | if row_idx <= rows_len - self.required_count: 46 | results.append([idxs[row_idx], self.logic(row_idx)]) 47 | else: 48 | results.append([idxs[row_idx], None]) 49 | 50 | else: 51 | self.multi_coeff = -1 52 | 53 | for row in range(0, rows_len, 1): 54 | 55 | if row >= self.required_count - 1: 56 | results.append([idxs[row], self.logic(row)]) 57 | else: 58 | results.append([idxs[row], None]) 59 | 60 | candles_df = candles_df.join(pd.DataFrame(results, columns=['row', self.target]).set_index('row'), 61 | how='outer') 62 | 63 | return candles_df 64 | else: 65 | raise Exception('Data is not prepared to detect patterns') 66 | 67 | def prepare_data(self, candles_df, ohlc): 68 | 69 | if isinstance(candles_df, pd.DataFrame): 70 | 71 | if len(candles_df) >= self.required_count: 72 | if ohlc and len(ohlc) == 4: 73 | if not set(ohlc).issubset(candles_df.columns): 74 | raise Exception('Provided columns does not exist in given data frame') 75 | 76 | self.open_column = ohlc[0] 77 | self.high_column = ohlc[1] 78 | self.low_column = ohlc[2] 79 | self.close_column = ohlc[3] 80 | else: 81 | raise Exception('Provide list of four elements indicating columns in strings. ' 82 | 'Default: [open, high, low, close]') 83 | 84 | self.data = candles_df.copy() 85 | 86 | if not is_numeric_dtype(self.data[self.close_column]): 87 | self.data[self.close_column] = pd.to_numeric(self.data[self.close_column]) 88 | 89 | if not is_numeric_dtype(self.data[self.open_column]): 90 | self.data[self.open_column] = pd.to_numeric(self.data[self.open_column]) 91 | 92 | if not is_numeric_dtype(self.data[self.low_column]): 93 | self.data[self.low_column] = pd.to_numeric(self.data[self.low_column]) 94 | 95 | if not is_numeric_dtype(self.data[self.high_column]): 96 | self.data[self.high_column] = pd.to_numeric(candles_df[self.high_column]) 97 | 98 | self.is_data_prepared = True 99 | else: 100 | raise Exception('{0} requires at least {1} data'.format(self.name, 101 | self.required_count)) 102 | else: 103 | raise Exception('Candles must be in Panda data frame type') 104 | -------------------------------------------------------------------------------- /candlestick/patterns/dark_cloud_cover.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class DarkCloudCover(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 2, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | prev_candle = self.data.iloc[idx + 1 * self.multi_coeff] 11 | 12 | close = candle[self.close_column] 13 | open = candle[self.open_column] 14 | high = candle[self.high_column] 15 | low = candle[self.low_column] 16 | 17 | prev_close = prev_candle[self.close_column] 18 | prev_open = prev_candle[self.open_column] 19 | prev_high = prev_candle[self.high_column] 20 | prev_low = prev_candle[self.low_column] 21 | 22 | # return prev_close > prev_open and \ 23 | # abs(prev_close - prev_open) / (prev_high - prev_low) >= 0.7 and \ 24 | # close < open and \ 25 | # abs(close - open) / (high - low) >= 0.7 and \ 26 | # open >= prev_close and \ 27 | # prev_open < close < (prev_open + prev_close) / 2 28 | 29 | return ((prev_close > prev_open) and 30 | (((prev_close + prev_open) / 2) > close) and 31 | (open > close) and 32 | (open > prev_close) and 33 | (close > prev_open) and 34 | ((open - close) / (.001 + (high - low)) > 0.6)) 35 | -------------------------------------------------------------------------------- /candlestick/patterns/doji.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class Doji(CandlestickFinder): 5 | 6 | def __init__(self, target=None): 7 | super().__init__(self.get_class_name(), 1, target=target) 8 | 9 | def logic(self, idx): 10 | candle = self.data.iloc[idx] 11 | 12 | close = candle[self.close_column] 13 | open = candle[self.open_column] 14 | high = candle[self.high_column] 15 | low = candle[self.low_column] 16 | 17 | return abs(close - open) / (high - low) < 0.1 and \ 18 | (high - max(close, open)) > (3 * abs(close - open)) and \ 19 | (min(close, open) - low) > (3 * abs(close - open)) 20 | -------------------------------------------------------------------------------- /candlestick/patterns/doji_star.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class DojiStar(CandlestickFinder): 5 | 6 | def __init__(self, target=None): 7 | super().__init__(self.get_class_name(), 2, target=target) 8 | 9 | def logic(self, idx): 10 | candle = self.data.iloc[idx] 11 | prev_candle = self.data.iloc[idx + 1 * self.multi_coeff] 12 | 13 | close = candle[self.close_column] 14 | open = candle[self.open_column] 15 | high = candle[self.high_column] 16 | low = candle[self.low_column] 17 | 18 | prev_close = prev_candle[self.close_column] 19 | prev_open = prev_candle[self.open_column] 20 | prev_high = prev_candle[self.high_column] 21 | prev_low = prev_candle[self.low_column] 22 | 23 | return prev_close > prev_open and \ 24 | abs(prev_close - prev_open) / (prev_high - prev_low) >= 0.7 and \ 25 | abs(close - open) / (high - low) < 0.1 and \ 26 | prev_close < close and \ 27 | prev_close < open and \ 28 | (high - max(close, open)) > (3 * abs(close - open)) and \ 29 | (min(close, open) - low) > (3 * abs(close - open)) 30 | -------------------------------------------------------------------------------- /candlestick/patterns/dragonfly_doji.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class DragonflyDoji(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 1, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | 11 | close = candle[self.close_column] 12 | open = candle[self.open_column] 13 | high = candle[self.high_column] 14 | low = candle[self.low_column] 15 | 16 | return abs(close - open) / (high - low) < 0.1 and \ 17 | (min(close, open) - low) > (3 * abs(close - open)) and \ 18 | (high - max(close, open)) < abs(close - open) 19 | -------------------------------------------------------------------------------- /candlestick/patterns/evening_star.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class EveningStar(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 3, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | prev_candle = self.data.iloc[idx + 1 * self.multi_coeff] 11 | b_prev_candle = self.data.iloc[idx + 2 * self.multi_coeff] 12 | 13 | close = candle[self.close_column] 14 | open = candle[self.open_column] 15 | high = candle[self.high_column] 16 | low = candle[self.low_column] 17 | 18 | prev_close = prev_candle[self.close_column] 19 | prev_open = prev_candle[self.open_column] 20 | prev_high = prev_candle[self.high_column] 21 | prev_low = prev_candle[self.low_column] 22 | 23 | b_prev_close = b_prev_candle[self.close_column] 24 | b_prev_open = b_prev_candle[self.open_column] 25 | b_prev_high = b_prev_candle[self.high_column] 26 | b_prev_low = b_prev_candle[self.low_column] 27 | 28 | # return (b_prev_close > b_prev_open and 29 | # abs(b_prev_close - b_prev_open) / (b_prev_high - b_prev_low) >= 0.7 and 30 | # 0.3 > abs(prev_close - prev_open) / (prev_high - prev_low) >= 0.1 and 31 | # close < open and 32 | # abs(close - open) / (high - low) >= 0.7 and 33 | # b_prev_close < prev_close and 34 | # b_prev_close < prev_open and 35 | # prev_close > open and 36 | # prev_open > open and 37 | # close < b_prev_close) 38 | 39 | return (min(prev_open, prev_close) > b_prev_close > b_prev_open and 40 | close < open < min(prev_open, prev_close)) 41 | -------------------------------------------------------------------------------- /candlestick/patterns/evening_star_doji.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class EveningStarDoji(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 3, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | prev_candle = self.data.iloc[idx + 1 * self.multi_coeff] 11 | b_prev_candle = self.data.iloc[idx + 2 * self.multi_coeff] 12 | 13 | close = candle[self.close_column] 14 | open = candle[self.open_column] 15 | high = candle[self.high_column] 16 | low = candle[self.low_column] 17 | 18 | prev_close = prev_candle[self.close_column] 19 | prev_open = prev_candle[self.open_column] 20 | prev_high = prev_candle[self.high_column] 21 | prev_low = prev_candle[self.low_column] 22 | 23 | b_prev_close = b_prev_candle[self.close_column] 24 | b_prev_open = b_prev_candle[self.open_column] 25 | b_prev_high = b_prev_candle[self.high_column] 26 | b_prev_low = b_prev_candle[self.low_column] 27 | 28 | return (b_prev_close > b_prev_open and 29 | abs(b_prev_close - b_prev_open) / (b_prev_high - b_prev_low) >= 0.7 and 30 | abs(prev_close - prev_open) / (prev_high - prev_low) < 0.1 and 31 | close < open and 32 | abs(close - open) / (high - low) >= 0.7 and 33 | b_prev_close < prev_close and 34 | b_prev_close < prev_open and 35 | prev_close > open and 36 | prev_open > open and 37 | close < b_prev_close 38 | and (prev_high - max(prev_close, prev_open)) > (3 * abs(prev_close - prev_open)) 39 | and (min(prev_close, prev_open) - prev_low) > (3 * abs(prev_close - prev_open))) 40 | -------------------------------------------------------------------------------- /candlestick/patterns/gravestone_doji.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class GravestoneDoji(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 1, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | 11 | close = candle[self.close_column] 12 | open = candle[self.open_column] 13 | high = candle[self.high_column] 14 | low = candle[self.low_column] 15 | 16 | return (abs(close - open) / (high - low) < 0.1 and 17 | (high - max(close, open)) > (3 * abs(close - open)) and 18 | (min(close, open) - low) <= abs(close - open)) 19 | -------------------------------------------------------------------------------- /candlestick/patterns/hammer.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class Hammer(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 1, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | 11 | close = candle[self.close_column] 12 | open = candle[self.open_column] 13 | high = candle[self.high_column] 14 | low = candle[self.low_column] 15 | 16 | return (((high - low) > 3 * (open - close)) and 17 | ((close - low) / (.001 + high - low) > 0.6) and 18 | ((open - low) / (.001 + high - low) > 0.6)) 19 | -------------------------------------------------------------------------------- /candlestick/patterns/hanging_man.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class HangingMan(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 3, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | prev_candle = self.data.iloc[idx + 1 * self.multi_coeff] 11 | b_prev_candle = self.data.iloc[idx + 2 * self.multi_coeff] 12 | 13 | close = candle[self.close_column] 14 | open = candle[self.open_column] 15 | high = candle[self.high_column] 16 | low = candle[self.low_column] 17 | 18 | prev_close = prev_candle[self.close_column] 19 | prev_open = prev_candle[self.open_column] 20 | prev_high = prev_candle[self.high_column] 21 | prev_low = prev_candle[self.low_column] 22 | 23 | b_prev_close = b_prev_candle[self.close_column] 24 | b_prev_open = b_prev_candle[self.open_column] 25 | b_prev_high = b_prev_candle[self.high_column] 26 | b_prev_low = b_prev_candle[self.low_column] 27 | 28 | # return (((high - low > 4 * (open - close)) and 29 | # ((close - low) / (.001 + high - low) >= 0.75) and 30 | # ((open - low) / (.001 + high - low) >= 0.75)) and 31 | # high[1] < open and 32 | # high[2] < open) 33 | 34 | return (((high - low > 4 * (open - close)) and 35 | ((close - low) / (.001 + high - low) >= 0.75) and 36 | ((open - low) / (.001 + high - low) >= 0.75)) and 37 | prev_high < open and 38 | b_prev_high < open) 39 | -------------------------------------------------------------------------------- /candlestick/patterns/inverted_hammer.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class InvertedHammer(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 1, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | 11 | close = candle[self.close_column] 12 | open = candle[self.open_column] 13 | high = candle[self.high_column] 14 | low = candle[self.low_column] 15 | 16 | return (((high - low) > 3 * (open - close)) and 17 | ((high - close) / (.001 + high - low) > 0.6) 18 | and ((high - open) / (.001 + high - low) > 0.6)) 19 | -------------------------------------------------------------------------------- /candlestick/patterns/morning_star.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class MorningStar(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 3, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | prev_candle = self.data.iloc[idx + 1 * self.multi_coeff] 11 | b_prev_candle = self.data.iloc[idx + 2 * self.multi_coeff] 12 | 13 | close = candle[self.close_column] 14 | open = candle[self.open_column] 15 | high = candle[self.high_column] 16 | low = candle[self.low_column] 17 | 18 | prev_close = prev_candle[self.close_column] 19 | prev_open = prev_candle[self.open_column] 20 | prev_high = prev_candle[self.high_column] 21 | prev_low = prev_candle[self.low_column] 22 | 23 | b_prev_close = b_prev_candle[self.close_column] 24 | b_prev_open = b_prev_candle[self.open_column] 25 | b_prev_high = b_prev_candle[self.high_column] 26 | b_prev_low = b_prev_candle[self.low_column] 27 | 28 | # return (b_prev_close < b_prev_open and 29 | # abs(b_prev_close - b_prev_open) / (b_prev_high - b_prev_low) >= 0.7 and 30 | # 0.3 > abs(prev_close - prev_open) / (prev_high - prev_low) >= 0.1 and 31 | # close > open and 32 | # abs(close - open) / (high - low) >= 0.7 and 33 | # b_prev_close > prev_close and 34 | # b_prev_close > prev_open and 35 | # prev_close < open and 36 | # prev_open < open and 37 | # close > b_prev_close) 38 | 39 | return (max(prev_open, prev_close) < b_prev_close < b_prev_open and 40 | close > open > max(prev_open, prev_close)) 41 | -------------------------------------------------------------------------------- /candlestick/patterns/morning_star_doji.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class MorningStarDoji(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 3, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | prev_candle = self.data.iloc[idx + 1 * self.multi_coeff] 11 | b_prev_candle = self.data.iloc[idx + 2 * self.multi_coeff] 12 | 13 | close = candle[self.close_column] 14 | open = candle[self.open_column] 15 | high = candle[self.high_column] 16 | low = candle[self.low_column] 17 | 18 | prev_close = prev_candle[self.close_column] 19 | prev_open = prev_candle[self.open_column] 20 | prev_high = prev_candle[self.high_column] 21 | prev_low = prev_candle[self.low_column] 22 | 23 | b_prev_close = b_prev_candle[self.close_column] 24 | b_prev_open = b_prev_candle[self.open_column] 25 | b_prev_high = b_prev_candle[self.high_column] 26 | b_prev_low = b_prev_candle[self.low_column] 27 | 28 | return (b_prev_close < b_prev_open and 29 | abs(b_prev_close - b_prev_open) / (b_prev_high - b_prev_low) >= 0.7 and 30 | abs(prev_close - prev_open) / (prev_high - prev_low) < 0.1 and 31 | close > open and 32 | abs(close - open) / (high - low) >= 0.7 and 33 | b_prev_close > prev_close and 34 | b_prev_close > prev_open and 35 | prev_close < open and 36 | prev_open < open and 37 | close > b_prev_close 38 | and (prev_high - max(prev_close, prev_open)) > (3 * abs(prev_close - prev_open)) 39 | and (min(prev_close, prev_open) - prev_low) > (3 * abs(prev_close - prev_open))) 40 | -------------------------------------------------------------------------------- /candlestick/patterns/piercing_pattern.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class PiercingPattern(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 2, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | prev_candle = self.data.iloc[idx + 1 * self.multi_coeff] 11 | 12 | close = candle[self.close_column] 13 | open = candle[self.open_column] 14 | high = candle[self.high_column] 15 | low = candle[self.low_column] 16 | 17 | prev_close = prev_candle[self.close_column] 18 | prev_open = prev_candle[self.open_column] 19 | prev_high = prev_candle[self.high_column] 20 | prev_low = prev_candle[self.low_column] 21 | 22 | # return (prev_close < prev_open and 23 | # abs(prev_close - prev_open) / (prev_high - prev_low) >= 0.7 and 24 | # close > open and 25 | # abs(close - open) / (high - low) >= 0.7 and 26 | # open <= prev_close and 27 | # close < prev_open and 28 | # close < ((prev_open + prev_close) / 2)) 29 | 30 | return (prev_close < prev_open and 31 | open < prev_low and 32 | prev_open > close > prev_close + ((prev_open - prev_close) / 2)) 33 | -------------------------------------------------------------------------------- /candlestick/patterns/rain_drop.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class RainDrop(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 2, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | prev_candle = self.data.iloc[idx + 1 * self.multi_coeff] 11 | 12 | close = candle[self.close_column] 13 | open = candle[self.open_column] 14 | high = candle[self.high_column] 15 | low = candle[self.low_column] 16 | 17 | prev_close = prev_candle[self.close_column] 18 | prev_open = prev_candle[self.open_column] 19 | prev_high = prev_candle[self.high_column] 20 | prev_low = prev_candle[self.low_column] 21 | 22 | return (prev_close < prev_open and 23 | abs(prev_close - prev_open) / (prev_high - prev_low) >= 0.7 and 24 | 0.3 > abs(close - open) / (high - low) >= 0.1 and 25 | prev_close > close and 26 | prev_close > open) 27 | -------------------------------------------------------------------------------- /candlestick/patterns/rain_drop_doji.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class RainDropDoji(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 2, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | prev_candle = self.data.iloc[idx + 1 * self.multi_coeff] 11 | 12 | close = candle[self.close_column] 13 | open = candle[self.open_column] 14 | high = candle[self.high_column] 15 | low = candle[self.low_column] 16 | 17 | prev_close = prev_candle[self.close_column] 18 | prev_open = prev_candle[self.open_column] 19 | prev_high = prev_candle[self.high_column] 20 | prev_low = prev_candle[self.low_column] 21 | 22 | return (prev_close < prev_open and 23 | abs(prev_close - prev_open) / (prev_high - prev_low) >= 0.7 and 24 | abs(close - open) / (high - low) < 0.1 and 25 | prev_close > close and 26 | prev_close > open and 27 | (high - max(close, open)) > (3 * abs(close - open)) and 28 | (min(close, open) - low) > (3 * abs(close - open))) 29 | -------------------------------------------------------------------------------- /candlestick/patterns/shooting_star.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class ShootingStar(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 2, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | prev_candle = self.data.iloc[idx + 1 * self.multi_coeff] 11 | 12 | close = candle[self.close_column] 13 | open = candle[self.open_column] 14 | high = candle[self.high_column] 15 | low = candle[self.low_column] 16 | 17 | prev_close = prev_candle[self.close_column] 18 | prev_open = prev_candle[self.open_column] 19 | prev_high = prev_candle[self.high_column] 20 | prev_low = prev_candle[self.low_column] 21 | 22 | return (prev_open < prev_close < open and 23 | high - max(open, close) >= abs(open - close) * 3 and 24 | min(close, open) - low <= abs(open - close)) 25 | -------------------------------------------------------------------------------- /candlestick/patterns/star.py: -------------------------------------------------------------------------------- 1 | from candlestick.patterns.candlestick_finder import CandlestickFinder 2 | 3 | 4 | class Star(CandlestickFinder): 5 | def __init__(self, target=None): 6 | super().__init__(self.get_class_name(), 2, target=target) 7 | 8 | def logic(self, idx): 9 | candle = self.data.iloc[idx] 10 | prev_candle = self.data.iloc[idx + 1 * self.multi_coeff] 11 | 12 | close = candle[self.close_column] 13 | open = candle[self.open_column] 14 | high = candle[self.high_column] 15 | low = candle[self.low_column] 16 | 17 | prev_close = prev_candle[self.close_column] 18 | prev_open = prev_candle[self.open_column] 19 | prev_high = prev_candle[self.high_column] 20 | prev_low = prev_candle[self.low_column] 21 | 22 | return (prev_close > prev_open and 23 | abs(prev_close - prev_open) / (prev_high - prev_low) >= 0.7 and 24 | 0.3 > abs(close - open) / (high - low) >= 0.1 and 25 | prev_close < close and 26 | prev_close < open) 27 | -------------------------------------------------------------------------------- /sample/binance_sample.py: -------------------------------------------------------------------------------- 1 | from candlestick import candlestick 2 | import pandas as pd 3 | import requests 4 | 5 | # Find candles where inverted hammer is detected 6 | 7 | candles = requests.get('https://api.binance.com/api/v1/klines?symbol=BTCUSDT&interval=1d') 8 | candles_dict = candles.json() 9 | 10 | candles_df = pd.DataFrame(candles_dict, 11 | columns=['T', 'open', 'high', 'low', 'close', 'V', 'CT', 'QV', 'N', 'TB', 'TQ', 'I']) 12 | 13 | candles_df['T'] = pd.to_datetime(candles_df['T'], unit='ms') 14 | 15 | target = 'InvertedHammers' 16 | candles_df = candlestick.inverted_hammer(candles_df, target=target) 17 | # candles_df = candlestick.doji_star(candles_df) 18 | # candles_df = candlestick.bearish_harami(candles_df) 19 | # candles_df = candlestick.bullish_harami(candles_df) 20 | # candles_df = candlestick.dark_cloud_cover(candles_df) 21 | # candles_df = candlestick.doji(candles_df) 22 | # candles_df = candlestick.dragonfly_doji(candles_df) 23 | # candles_df = candlestick.hanging_man(candles_df) 24 | # candles_df = candlestick.gravestone_doji(candles_df) 25 | # candles_df = candlestick.bearish_engulfing(candles_df) 26 | # candles_df = candlestick.bullish_engulfing(candles_df) 27 | # candles_df = candlestick.hammer(candles_df) 28 | # candles_df = candlestick.morning_star(candles_df) 29 | # candles_df = candlestick.morning_star_doji(candles_df) 30 | # candles_df = candlestick.piercing_pattern(candles_df) 31 | # candles_df = candlestick.rain_drop(candles_df) 32 | # candles_df = candlestick.rain_drop_doji(candles_df) 33 | # candles_df = candlestick.star(candles_df) 34 | # candles_df = candlestick.shooting_star(candles_df) 35 | 36 | print(candles_df[candles_df[target] == True][['T', target]]) 37 | --------------------------------------------------------------------------------