diff --git a/examples/panels.ipynb b/examples/panels.ipynb index 75c9164c..3212577f 100644 --- a/examples/panels.ipynb +++ b/examples/panels.ipynb @@ -17,7 +17,7 @@ "![sample_subplot](data/sample_subplot.png)\n", "\n", "### Features and Basic Terminology\n", - "* Panels are identified by their \"Panel ID\", an integer ranging from 0 to 9.\n", + "* Panels are identified by their \"Panel ID\", an integer ranging from 0 to 31.\n", "* Panel ID's are always numbered from top to bottom, thus:\n", " - Panel 0 is always the uppermost panel, Panel 1 is just below that, and so on.\n", "* The \"*main panel*\" is the panel where candlesticks/ohlc data are plotted.\n", diff --git a/examples/plot_customizations.ipynb b/examples/plot_customizations.ipynb index dc1642c1..e51b45a8 100644 --- a/examples/plot_customizations.ipynb +++ b/examples/plot_customizations.ipynb @@ -223,7 +223,7 @@ { "data": { "text/plain": [ - "'0.12.9b0'" + "'0.12.9b3'" ] }, "execution_count": 4, @@ -359,9 +359,16 @@ "\n", "---\n", "\n", - "#### Setting the Figure Title and the Y-axis Label:" + "#### Setting the Figure Title, the Y-axis Label, and the X-axis Label:" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": 7, @@ -369,7 +376,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -382,16 +389,10 @@ "mpf.plot(daily,type='candle',volume=True,\n", " title='\\nS&P 500, Nov 2019',\n", " ylabel='OHLC Candles',\n", - " ylabel_lower='Shares\\nTraded')" + " ylabel_lower='Shares\\nTraded',\n", + " xlabel='DATE')" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "markdown", "metadata": {}, diff --git a/markdown/subplots.md b/markdown/subplots.md index 0a7fa5b8..0a43f04c 100644 --- a/markdown/subplots.md +++ b/markdown/subplots.md @@ -17,10 +17,10 @@ * The Panels Method attains its simplicity, in part, by having certain limitations.
These limitiations are: - Subplots are always stacked vertically. - All subplots share the same x-axis. - - There is a maximum of 10 subplots. + - There is a maximum of 32 subplots. * The Panels Method is adequate to plot: - ohlc, candlesticks, etc. - - with volume, and + - with volume, and - with one or more studies/indicators, such as: - MACD, DMI, RSI, Bollinger, Accumulation/Distribution Oscillator, Commodity Channel Index, Etc. * [**See here for a tutorial and details on implementing the mplfinance Panels Method for subplots.**](https://github.com/matplotlib/mplfinance/blob/master/examples/panels.ipynb) diff --git a/src/mplfinance/_arg_validators.py b/src/mplfinance/_arg_validators.py index d7398232..55c320b3 100644 --- a/src/mplfinance/_arg_validators.py +++ b/src/mplfinance/_arg_validators.py @@ -30,21 +30,6 @@ def _check_and_prepare_data(data, config): if not isinstance(data.index,pd.core.indexes.datetimes.DatetimeIndex): raise TypeError('Expect data.index as DatetimeIndex') - if (len(data.index) > config['warn_too_much_data'] and - (config['type']=='candle' or config['type']=='ohlc' or config['type']=='hollow_and_filled') - ): - warnings.warn('\n\n ================================================================= '+ - '\n\n WARNING: YOU ARE PLOTTING SO MUCH DATA THAT IT MAY NOT BE'+ - '\n POSSIBLE TO SEE DETAILS (Candles, Ohlc-Bars, Etc.)'+ - '\n For more information see:'+ - '\n - https://github.com/matplotlib/mplfinance/wiki/Plotting-Too-Much-Data'+ - '\n '+ - '\n TO SILENCE THIS WARNING, set `type=\'line\'` in `mpf.plot()`'+ - '\n OR set kwarg `warn_too_much_data=N` where N is an integer '+ - '\n LARGER than the number of data points you want to plot.'+ - '\n\n ================================================================ ', - category=UserWarning) - # We will not be fully case-insensitive (since Pandas columns as NOT case-insensitive) # but because so many people have requested it, for the default column names we will # try both Capitalized and lower case: @@ -57,10 +42,22 @@ def _check_and_prepare_data(data, config): o, h, l, c, v = columns cols = [o, h, l, c] - if config['tz_localize']: - dates = mdates.date2num(data.index.tz_localize(None).to_pydatetime()) - else: # Just in case someone was depending on this bug (Issue 236) - dates = mdates.date2num(data.index.to_pydatetime()) + if config['volume'] != False: + expect_cols = columns + else: + expect_cols = cols + + for col in expect_cols: + if col not in data.columns: + for dc in data.columns: + if dc.strip() != dc: + warnings.warn('\n ================================================================= '+ + '\n Input DataFrame column name "'+dc+'" '+ + '\n contains leading and/or trailing whitespace.',category=UserWarning) + raise ValueError('Column "'+col+'" NOT FOUND in Input DataFrame!'+ + '\n CHECK that your column names are correct AND/OR'+ + '\n CHECK for leading or trailing blanks in your column names.') + opens = data[o].values highs = data[h].values lows = data[l].values @@ -75,6 +72,26 @@ def _check_and_prepare_data(data, config): if not all( isinstance(v,(float,int)) for v in data[col] ): raise ValueError('Data for column "'+str(col)+'" must be ALL float or int.') + if config['tz_localize']: + dates = mdates.date2num(data.index.tz_localize(None).to_pydatetime()) + else: # Just in case someone was depending on this bug (Issue 236) + dates = mdates.date2num(data.index.to_pydatetime()) + + if (len(data.index) > config['warn_too_much_data'] and + (config['type']=='candle' or config['type']=='ohlc' or config['type']=='hollow_and_filled') + ): + warnings.warn('\n\n ================================================================= '+ + '\n\n WARNING: YOU ARE PLOTTING SO MUCH DATA THAT IT MAY NOT BE'+ + '\n POSSIBLE TO SEE DETAILS (Candles, Ohlc-Bars, Etc.)'+ + '\n For more information see:'+ + '\n - https://github.com/matplotlib/mplfinance/wiki/Plotting-Too-Much-Data'+ + '\n '+ + '\n TO SILENCE THIS WARNING, set `type=\'line\'` in `mpf.plot()`'+ + '\n OR set kwarg `warn_too_much_data=N` where N is an integer '+ + '\n LARGER than the number of data points you want to plot.'+ + '\n\n ================================================================ ', + category=UserWarning) + return dates, opens, highs, lows, closes, volumes def _get_valid_plot_types(plottype=None): diff --git a/src/mplfinance/_panels.py b/src/mplfinance/_panels.py index 7d8524a2..c1b8bef1 100644 --- a/src/mplfinance/_panels.py +++ b/src/mplfinance/_panels.py @@ -218,15 +218,22 @@ def _build_panels( figure, config ): return panels -def _set_ticks_on_bottom_panel_only(panels,formatter,rotation=45): +def _set_ticks_on_bottom_panel_only(panels,formatter,rotation=45,xlabel=None): bot = panels.index.values[-1] ax = panels.at[bot,'axes'][0] ax.tick_params(axis='x',rotation=rotation) ax.xaxis.set_major_formatter(formatter) + if xlabel is not None: + ax.set_xlabel(xlabel) + if len(panels) == 1: return + # [::-1] reverses the order of the panel id's + # [1:] all but the first element, which, since the array + # is reversed, means we take all but the LAST panel id. + # Thus, only the last (bottom) panel id gets tick labels: for panid in panels.index.values[::-1][1:]: panels.at[panid,'axes'][0].tick_params(axis='x',labelbottom=False) diff --git a/src/mplfinance/_utils.py b/src/mplfinance/_utils.py index 447a52ea..a4f80dfc 100644 --- a/src/mplfinance/_utils.py +++ b/src/mplfinance/_utils.py @@ -9,7 +9,7 @@ from itertools import cycle -from matplotlib import colors as mcolors +from matplotlib import colors as mcolors, pyplot as plt from matplotlib.patches import Ellipse from matplotlib.collections import LineCollection, PolyCollection, PatchCollection @@ -83,7 +83,7 @@ def _check_and_convert_xlim_configuration(data, config): xlim = [ _date_to_mdate(dt) for dt in xlim] else: xlim = [ _date_to_iloc_extrapolate(data.index.to_series(),dt) for dt in xlim] - + return xlim @@ -109,7 +109,7 @@ def _construct_mpf_collections(ptype,dates,xdates,opens,highs,lows,closes,volume dates, highs, lows, volumes, config['pnf_params'], closes, marketcolors=style['marketcolors']) else: raise TypeError('Unknown ptype="',str(ptype),'"') - + return collections @@ -140,7 +140,7 @@ def combine_adjacent(arr): Returns ------- output: new summed array - indexes: indexes indicating the first + indexes: indexes indicating the first element summed for each group in arr """ output, indexes = [], [] @@ -153,7 +153,7 @@ def combine_adjacent(arr): output.append(sum(arr[:index])) indexes.append(curr_i) curr_i += index - + for _ in range(index): arr.pop(0) return output, indexes @@ -190,7 +190,7 @@ def _updown_colors(upcolor,downcolor,opens,closes,use_prev_close=False): if not use_prev_close: return [ cmap[opn < cls] for opn,cls in zip(opens,closes) ] else: - first = cmap[opens[0] < closes[0]] + first = cmap[opens[0] < closes[0]] _list = [ cmap[pre < cls] for cls,pre in zip(closes[1:], closes) ] return [first] + _list @@ -208,8 +208,8 @@ def _make_updown_color_list(key,marketcolors,opens,closes,overrides=None): ups[ix] = mco[key][ 'up' ] downs[ix] = mco[key]['down'] return [ups[ix] if opens[ix] < closes[ix] else downs[ix] for ix in range(length)] - - + + def _updownhollow_colors(upcolor,downcolor,hollowcolor,opens,closes): if upcolor == downcolor: return upcolor @@ -221,7 +221,7 @@ def _updownhollow_colors(upcolor,downcolor,hollowcolor,opens,closes): def _date_to_iloc(dtseries,date): - '''Convert a `date` to a location, given a date series w/a datetime index. + '''Convert a `date` to a location, given a date series w/a datetime index. If `date` does not exactly match a date in the series then interpolate between two dates. If `date` is outside the range of dates in the series, then raise an exception . @@ -258,7 +258,7 @@ def _date_to_iloc_linear(dtseries,date,trace=False): i1 = 0.0 i2 = len(dtseries) - 1.0 if trace: print('i1,i2=',i1,i2) - + slope = (i2 - i1) / (d2 - d1) yitrcpt1 = i1 - (slope*d1) if trace: print('slope,yitrcpt=',slope,yitrcpt1) @@ -268,7 +268,7 @@ def _date_to_iloc_linear(dtseries,date,trace=False): print('WARNING: yintercepts NOT equal!!!(',yitrcpt1,yitrcpt2,')') yitrcpt = (yitrcpt1 + yitrcpt2) / 2.0 else: - yitrcpt = yitrcpt1 + yitrcpt = yitrcpt1 return (slope * _date_to_mdate(date)) + yitrcpt def _date_to_iloc_5_7ths(dtseries,date,direction,trace=False): @@ -288,14 +288,14 @@ def _date_to_iloc_5_7ths(dtseries,date,direction,trace=False): return loc_5_7ths def _date_to_iloc_extrapolate(dtseries,date): - '''Convert a `date` to a location, given a date series w/a datetime index. + '''Convert a `date` to a location, given a date series w/a datetime index. If `date` does not exactly match a date in the series then interpolate between two dates. If `date` is outside the range of dates in the series, then extrapolate: Extrapolation results in increased error as the distance of the extrapolation increases. We have two methods to extrapolate: (1) Determine a linear equation based on the data provided in `dtseries`, and use that equation to calculate the location for the date. - (2) Multiply by 5/7 the number of days between the edge date of dtseries and the + (2) Multiply by 5/7 the number of days between the edge date of dtseries and the date for which we are requesting a location. THIS ASSUMES DAILY data AND a 5 DAY TRADING WEEK. Empirical observation (scratch_pad/date_to_iloc_extrapolation.ipynb) shows that @@ -348,7 +348,7 @@ def _date_to_mdate(date): def _convert_segment_dates(segments,dtindex): ''' - Convert line segment dates to matplotlib dates + Convert line segment dates to matplotlib dates Inputted segment dates may be: pandas-parseable date-time string, pandas timestamp, or a python datetime or date, or (if dtindex is not None) integer index A "segment" is a "sequence of lines", @@ -363,7 +363,7 @@ def _convert_segment_dates(segments,dtindex): new_line = [] for dt,value in line: if dtindex is not None: - date = _date_to_iloc(dtseries,dt) + date = _date_to_iloc(dtseries,dt) else: date = _date_to_mdate(dt) if date is None: @@ -374,14 +374,14 @@ def _convert_segment_dates(segments,dtindex): def _valid_renko_kwargs(): ''' - Construct and return the "valid renko kwargs table" for the mplfinance.plot(type='renko') - function. A valid kwargs table is a `dict` of `dict`s. The keys of the outer dict are - the valid key-words for the function. The value for each key is a dict containing 3 + Construct and return the "valid renko kwargs table" for the mplfinance.plot(type='renko') + function. A valid kwargs table is a `dict` of `dict`s. The keys of the outer dict are + the valid key-words for the function. The value for each key is a dict containing 3 specific keys: "Default", "Description" and "Validator" with the following values: "Default" - The default value for the kwarg if none is specified. "Description" - The description for the kwarg. "Validator" - A function that takes the caller specified value for the kwarg, - and validates that it is the correct type, and (for kwargs with + and validates that it is the correct type, and (for kwargs with a limited set of allowed values) may also validate that the kwarg value is one of the allowed values. ''' @@ -404,14 +404,14 @@ def _valid_renko_kwargs(): def _valid_pnf_kwargs(): ''' - Construct and return the "valid pnf kwargs table" for the mplfinance.plot(type='pnf') - function. A valid kwargs table is a `dict` of `dict`s. The keys of the outer dict are - the valid key-words for the function. The value for each key is a dict containing 3 + Construct and return the "valid pnf kwargs table" for the mplfinance.plot(type='pnf') + function. A valid kwargs table is a `dict` of `dict`s. The keys of the outer dict are + the valid key-words for the function. The value for each key is a dict containing 3 specific keys: "Default", "Description" and "Validator" with the following values: "Default" - The default value for the kwarg if none is specified. "Description" - The description for the kwarg. "Validator" - A function that takes the caller specified value for the kwarg, - and validates that it is the correct type, and (for kwargs with + and validates that it is the correct type, and (for kwargs with a limited set of allowed values) may also validate that the kwarg value is one of the allowed values. ''' @@ -439,15 +439,15 @@ def _valid_pnf_kwargs(): def _valid_lines_kwargs(): ''' - Construct and return the "valid lines (hlines,vlines,alines,tlines) kwargs table" + Construct and return the "valid lines (hlines,vlines,alines,tlines) kwargs table" for the mplfinance.plot() `[h|v|a|t]lines=` kwarg functions. - A valid kwargs table is a `dict` of `dict`s. The keys of the outer dict are - the valid key-words for the function. The value for each key is a dict containing 3 + A valid kwargs table is a `dict` of `dict`s. The keys of the outer dict are + the valid key-words for the function. The value for each key is a dict containing 3 specific keys: "Default", "Description" and "Validator" with the following values: "Default" - The default value for the kwarg if none is specified. "Description" - The description for the kwarg. "Validator" - A function that takes the caller specified value for the kwarg, - and validates that it is the correct type, and (for kwargs with + and validates that it is the correct type, and (for kwargs with a limited set of allowed values) may also validate that the kwarg value is one of the allowed values. ''' @@ -496,17 +496,19 @@ def _valid_lines_kwargs(): 'Description' : 'line style of [hvat]lines (or sequence of line styles, if each line to have a different linestyle)', 'Validator' : lambda value: value is None or value in valid_linestyles or all([v in valid_linestyles for v in value]) }, - + 'linewidths': { 'Default' : None, 'Description' : 'line width of [hvat]lines (or sequence of line widths, if each line to have a different width)', 'Validator' : lambda value: value is None or isinstance(value,(float,int)) or all([isinstance(v,(float,int)) for v in value]) }, - 'alpha' : { 'Default' : 1.0, - 'Description' : 'Opacity of [hvat]lines. float from 0.0 to 1.0 '+ - ' (1.0 means fully opaque; 0.0 means transparent.', - 'Validator' : lambda value: isinstance(value,(float,int)) }, + 'alpha': {'Default': 1.0, + 'Description': 'Opacity of [hvat]lines (or sequence of opacities,' + + 'if each line is to have a different opacity)' + + 'float from 0.0 to 1.0 ' + ' (1.0 means fully opaque; 0.0 means transparent.', + 'Validator': lambda value: isinstance(value, (float, int)) + or all([isinstance(v, (float, int)) for v in value])}, 'tline_use' : { 'Default' : 'close', @@ -549,7 +551,7 @@ def _construct_ohlc_collections(dates, opens, highs, lows, closes, marketcolors= Returns ------- - ret : list + ret : list a list or tuple of matplotlib collections to be added to the axes """ @@ -629,7 +631,7 @@ def _construct_candlestick_collections(dates, opens, highs, lows, closes, market ret : list (lineCollection, barCollection) """ - + _check_input(opens, highs, lows, closes) if marketcolors is None: @@ -649,10 +651,10 @@ def _construct_candlestick_collections(dates, opens, highs, lows, closes, market rangeSegLow = [((date, low), (date, min(open,close))) for date, low, open, close in zip(dates, lows, opens, closes)] - + rangeSegHigh = [((date, high), (date, max(open,close))) for date, high, open, close in zip(dates, highs, opens, closes)] - + rangeSegments = rangeSegLow + rangeSegHigh alpha = marketcolors['alpha'] @@ -685,7 +687,7 @@ def _construct_candlestick_collections(dates, opens, highs, lows, closes, market def _construct_hollow_candlestick_collections(dates, opens, highs, lows, closes, marketcolors=None, config=None): """Represent today's open to close as a "bar" line (candle body) and high low range as a vertical line (candle wick) - + If config['type']=='hollow_and_filled' (hollow and filled candles) then candle edge and wick color depend on PREVIOUS close to today's close (up or down), and the center of the candle body (hollow or filled) depends on the today's open to close (up or down). @@ -712,7 +714,7 @@ def _construct_hollow_candlestick_collections(dates, opens, highs, lows, closes, ret : list (lineCollection, barCollection) """ - + _check_input(opens, highs, lows, closes) if marketcolors is None: @@ -732,23 +734,23 @@ def _construct_hollow_candlestick_collections(dates, opens, highs, lows, closes, rangeSegLow = [((date, low), (date, min(open,close))) for date, low, open, close in zip(dates, lows, opens, closes)] - + rangeSegHigh = [((date, high), (date, max(open,close))) for date, high, open, close in zip(dates, highs, opens, closes)] - + rangeSegments = rangeSegLow + rangeSegHigh alpha = marketcolors['alpha'] uc = mcolors.to_rgba(marketcolors['candle'][ 'up' ], alpha) dc = mcolors.to_rgba(marketcolors['candle']['down'], alpha) - + hc = mcolors.to_rgba(marketcolors['hollow']) if 'hollow' in marketcolors else (0,0,0,0) - + colors = _updownhollow_colors(uc, dc, hc, opens, closes) # for candle body. edgecolor = _updown_colors(uc, dc, opens, closes, use_prev_close=True) - + wickcolor = _updown_colors(uc, dc, opens, closes, use_prev_close=True) # For hollow candles, we scale the candle linewidth up a little: @@ -778,19 +780,19 @@ def _construct_renko_collections(dates, highs, lows, volumes, config_renko_param --------------------- In the first part of the algorithm, we populate the cdiff array along with adjusting the dates and volumes arrays into the new_dates and - new_volumes arrays. A single date includes a range from no bricks to many - bricks, if a date has no bricks it shall not be included in new_dates, - and if it has n bricks then it will be included n times. Volumes use a + new_volumes arrays. A single date includes a range from no bricks to many + bricks, if a date has no bricks it shall not be included in new_dates, + and if it has n bricks then it will be included n times. Volumes use a volume cache to save volume amounts for dates that do not have any bricks before adding the cache to the next date that has at least one brick. - We populate the cdiff array with each close values difference from the + We populate the cdiff array with each close values difference from the previously created brick divided by the brick size. In the second part of the algorithm, we iterate through the values in cdiff - and add 1s or -1s to the bricks array depending on whether the value is + and add 1s or -1s to the bricks array depending on whether the value is positive or negative. Every time there is a trend change (ex. previous brick is an upbrick, current brick is a down brick) we draw one less brick to account - for the price having to move the previous bricks amount before creating a + for the price having to move the previous bricks amount before creating a brick in the opposite direction. In the final part of the algorithm, we enumerate through the bricks array and @@ -801,7 +803,7 @@ def _construct_renko_collections(dates, highs, lows, volumes, config_renko_param Useful sources: https://avilpage.com/2018/01/how-to-plot-renko-charts-with-python.html https://school.stockcharts.com/doku.php?id=chart_analysis:renko - + Parameters ---------- dates : sequence @@ -825,10 +827,10 @@ def _construct_renko_collections(dates, highs, lows, volumes, config_renko_param renko_params = _process_kwargs(config_renko_params, _valid_renko_kwargs()) if marketcolors is None: marketcolors = _get_mpfstyle('classic')['marketcolors'] - + brick_size = renko_params['brick_size'] atr_length = renko_params['atr_length'] - + if brick_size == 'atr': if atr_length == 'total': @@ -849,7 +851,7 @@ def _construct_renko_collections(dates, highs, lows, volumes, config_renko_param dc = mcolors.to_rgba(marketcolors['candle']['down'], alpha) euc = mcolors.to_rgba(marketcolors['edge'][ 'up' ], 1.0) edc = mcolors.to_rgba(marketcolors['edge']['down'], 1.0) - + cdiff = [] # holds the differences between each close and the previously created brick / the brick size prev_close_brick = closes[0] volume_cache = 0 # holds the volumes for the dates that were skipped @@ -876,7 +878,7 @@ def _construct_renko_collections(dates, highs, lows, volumes, config_renko_param last_diff_sign = 0 # direction the bricks were last going in -1 -> down, 1 -> up dates_volumes_index = 0 # keeps track of the index of the current date/volume for diff in cdiff: - + curr_diff_sign = diff/abs(diff) if last_diff_sign != 0 and curr_diff_sign != last_diff_sign: last_diff_sign = curr_diff_sign @@ -889,7 +891,7 @@ def _construct_renko_collections(dates, highs, lows, volumes, config_renko_param new_volumes.pop(dates_volumes_index) continue last_diff_sign = curr_diff_sign - + if diff > 0: bricks.extend([1]*abs(diff)) else: @@ -911,7 +913,7 @@ def _construct_renko_collections(dates, highs, lows, volumes, config_renko_param curr_price += (brick_size * number) brick_values.append(curr_price) - + x, y = index, curr_price verts.append(( @@ -943,41 +945,41 @@ def _construct_pointnfig_collections(dates, highs, lows, volumes, config_pointnf --------------------- In the first part of the algorithm, we populate the boxes array along with adjusting the dates and volumes arrays into the new_dates and - new_volumes arrays. A single date includes a range from no boxes to many - boxes, if a date has no boxes it shall not be included in new_dates, - and if it has n boxes then it will be included n times. Volumes use a + new_volumes arrays. A single date includes a range from no boxes to many + boxes, if a date has no boxes it shall not be included in new_dates, + and if it has n boxes then it will be included n times. Volumes use a volume cache to save volume amounts for dates that do not have any boxes before adding the cache to the next date that has at least one box. - We populate the boxes array with each close values difference from the + We populate the boxes array with each close values difference from the previously created brick divided by the box size. The second part of the algorithm has a series of step. First we combine the adjacent like signed values in the boxes array (ex. [-1, -2, 3, -4] -> [-3, 3, -4]). - Next we subtract 1 from the absolute value of each element in boxes except the + Next we subtract 1 from the absolute value of each element in boxes except the first to ensure every time there is a trend change (ex. previous box is - an X, current brick is a O) we draw one less box to account for the price - having to move the previous box's amount before creating a box in the - opposite direction. During this same step we also combine like signed elements - and associated volume/date data ignoring any zero values that are created by - subtracting 1 from the box value. Next we recreate the box array utilizing a - rolling_change and volume_cache to store and sum the changes that don't break + an X, current brick is a O) we draw one less box to account for the price + having to move the previous box's amount before creating a box in the + opposite direction. During this same step we also combine like signed elements + and associated volume/date data ignoring any zero values that are created by + subtracting 1 from the box value. Next we recreate the box array utilizing a + rolling_change and volume_cache to store and sum the changes that don't break the reversal threshold. Lastly, we enumerate through the boxes to populate the line_seg and circle_patches - arrays. line_seg holds the / and \ line segments that make up an X and + arrays. line_seg holds the / and \ line segments that make up an X and circle_patches holds matplotlib.patches Ellipse objects for each O. We start - by filling an x and y array each iteration which contain the x and y + by filling an x and y array each iteration which contain the x and y coordinates for each box in the column. Then for each coordinate pair in - x, y we add to either the line_seg array or the circle_patches array - depending on the value of sign for the current column (1 indicates - line_seg, -1 indicates circle_patches). The height of the boxes take - into account padding which separates each box by a small margin in + x, y we add to either the line_seg array or the circle_patches array + depending on the value of sign for the current column (1 indicates + line_seg, -1 indicates circle_patches). The height of the boxes take + into account padding which separates each box by a small margin in order to increase readability. Useful sources: https://stackoverflow.com/questions/8750648/point-and-figure-chart-with-matplotlib https://www.investopedia.com/articles/technical/03/081303.asp - + Parameters ---------- dates : sequence @@ -1001,7 +1003,7 @@ def _construct_pointnfig_collections(dates, highs, lows, volumes, config_pointnf pointnfig_params = _process_kwargs(config_pointnfig_params, _valid_pnf_kwargs()) if marketcolors is None: marketcolors = _get_mpfstyle('classic')['marketcolors'] - + box_size = pointnfig_params['box_size'] atr_length = pointnfig_params['atr_length'] reversal = pointnfig_params['reversal'] @@ -1021,7 +1023,7 @@ def _construct_pointnfig_collections(dates, highs, lows, volumes, config_pointnf if reversal < 1 or reversal > 9: raise ValueError("Specified reversal must be an integer in the range [1,9]") - + alpha = marketcolors['alpha'] uc = mcolors.to_rgba(marketcolors['ohlc'][ 'up' ], alpha) @@ -1032,7 +1034,7 @@ def _construct_pointnfig_collections(dates, highs, lows, volumes, config_pointnf prev_close_box = closes[0] # represents the value of the last box in the previous column volume_cache = 0 # holds the volumes for the dates that were skipped temp_volumes, temp_dates = [], [] # holds the temp adjusted volumes and dates respectively - + for i in range(len(closes)-1): box_diff = int((closes[i+1] - prev_close_box) / box_size) if box_diff == 0: @@ -1050,7 +1052,7 @@ def _construct_pointnfig_collections(dates, highs, lows, volumes, config_pointnf # combine adjacent similarly signed differences boxes, indexes = combine_adjacent(boxes) new_volumes, new_dates = coalesce_volume_dates(temp_volumes, temp_dates, indexes) - + adjusted_boxes = [boxes[0]] temp_volumes, temp_dates = [new_volumes[0]], [new_dates[0]] volume_cache = 0 @@ -1086,7 +1088,7 @@ def _construct_pointnfig_collections(dates, highs, lows, volumes, config_pointnf boxes = [adjusted_boxes[0]] new_volumes = [temp_volumes[0]] new_dates = [temp_dates[0]] - + rolling_change = 0 volume_cache = 0 biggest_difference = 0 # only used for the last column @@ -1094,11 +1096,11 @@ def _construct_pointnfig_collections(dates, highs, lows, volumes, config_pointnf #Clean data to account for reversal size (added to allow overriding the default reversal of 1) for i in range(1, len(adjusted_boxes)): - # Add to rolling_change and volume_cache which stores the box and volume values + # Add to rolling_change and volume_cache which stores the box and volume values rolling_change += adjusted_boxes[i] volume_cache += temp_volumes[i] - # if rolling_change is the same sign as the previous box and the abs value is bigger than the + # if rolling_change is the same sign as the previous box and the abs value is bigger than the # abs value of biggest_difference then we should replace biggest_difference with rolling_change if rolling_change*boxes[-1] > 0 and abs(rolling_change) > abs(biggest_difference): biggest_difference = rolling_change @@ -1116,14 +1118,14 @@ def _construct_pointnfig_collections(dates, highs, lows, volumes, config_pointnf boxes.append(rolling_change) new_volumes.append(volume_cache) new_dates.append(temp_dates[i]) - + # reset rolling_change and volume_cache once we've used them rolling_change = 0 volume_cache = 0 - + # reset biggest_difference as we start from the beginning every time there is a reversal biggest_difference = 0 - + # Adjust the last box column if the left over rolling_change is the same sign as the column boxes[-1] += biggest_difference new_volumes[-1] += volume_cache @@ -1138,33 +1140,33 @@ def _construct_pointnfig_collections(dates, highs, lows, volumes, config_pointnf sign = (difference / abs(difference)) # -1 or 1 start_iteration = 0 if sign > 0 else 1 - + x = [index] * (diff) y = [curr_price + (i * box_size * sign) for i in range(start_iteration, diff+start_iteration)] curr_price += (box_size * sign * (diff)) box_values.append( y ) - + for i in range(len(x)): # x and y have the same length height = box_size * 0.85 width = 0.6 if height < 0.5: width = height - + padding = (box_size * 0.075) if sign == 1: # X line_seg.append([(x[i]-width/2, y[i] + padding), (x[i]+width/2, y[i]+height + padding)]) # create / part of the X line_seg.append([(x[i]-width/2, y[i]+height+padding), (x[i]+width/2, y[i]+padding)]) # create \ part of the X else: # O circle_patches.append(Ellipse((x[i], y[i]-(height/2) - padding), width, height)) - + useAA = 0, # use tuple here - lw = 0.5 + lw = 0.5 cirCollection = PatchCollection(circle_patches) cirCollection.set_facecolor([tfc] * len(circle_patches)) cirCollection.set_edgecolor([dc] * len(circle_patches)) - + xCollection = LineCollection(line_seg, colors=[uc] * len(line_seg), linewidths=lw, @@ -1182,7 +1184,7 @@ def _construct_aline_collections(alines, dtix=None): ---------- alines : sequence sequences of segments, which are sequences of lines, - which are sequences of two or more points ( date[time], price ) or (x,y) + which are sequences of two or more points ( date[time], price ) or (x,y) date[time] may be (a) pandas.to_datetime parseable string, (b) pandas Timestamp, or @@ -1269,7 +1271,7 @@ def _construct_hline_collections(hlines,minx,maxx): #print('hconfig=',hconfig) #print('hlines=',hlines) - + lines = [] if not isinstance(hlines,(list,tuple)): hlines = [hlines,] # may be a single price value @@ -1332,7 +1334,7 @@ def _construct_vline_collections(vlines,dtix,miny,maxy): #print('vconfig=',vconfig) #print('vlines=',vlines) - + if not isinstance(vlines,(list,tuple)): vlines = [vlines,] @@ -1416,7 +1418,7 @@ def _tline_lsq(dfslice,tline_use): https://mmas.github.io/least-squares-fitting-numpy-scipy ''' si = dfslice[tline_use].mean(axis=1) - s = si.dropna() + s = si.dropna() if len(s) < 2: err = 'NOT enough data for Least Squares' if (len(si) > 2): @@ -1453,7 +1455,7 @@ def _tline_lsq(dfslice,tline_use): alines.append((p1,p2)) del tconfig['alines'] - alines = dict(alines=alines,**tconfig) + alines = dict(alines=alines,**tconfig) alines['tlines'] = None return _construct_aline_collections(alines, dtix) @@ -1471,7 +1473,7 @@ class IntegerIndexDateTimeFormatter(Formatter): you would otherwise plot on that axis. Construct this formatter by providing the arrange of datetimes (as matplotlib floats). When the formatter receives an integer in the range, it will look up the - datetime and format it. + datetime and format it. """ def __init__(self, dates, fmt='%b %d, %H:%M'): @@ -1485,7 +1487,7 @@ def __call__(self, x, pos=0): # not sure what 'pos' is for: see # https://matplotlib.org/gallery/ticks_and_spines/date_index_formatter.html ix = int(np.round(x)) - + if ix >= self.len or ix < 0: date = None dateformat = '' diff --git a/src/mplfinance/_version.py b/src/mplfinance/_version.py index 9bca395f..52221d42 100644 --- a/src/mplfinance/_version.py +++ b/src/mplfinance/_version.py @@ -1,4 +1,4 @@ -version_info = (0, 12, 9, 'beta', 1) +version_info = (0, 12, 9, 'beta', 5) _specifier_ = {'alpha': 'a','beta': 'b','candidate': 'rc','final': ''} diff --git a/src/mplfinance/plotting.py b/src/mplfinance/plotting.py index b3d4f341..4e849f92 100644 --- a/src/mplfinance/plotting.py +++ b/src/mplfinance/plotting.py @@ -119,7 +119,17 @@ def _valid_plot_kwargs(): 'mav' : { 'Default' : None, 'Description' : 'Moving Average window size(s); (int or tuple of ints)', 'Validator' : _mav_validator }, + + 'ema' : { 'Default' : None, + 'Description' : 'Exponential Moving Average window size(s); (int or tuple of ints)', + 'Validator' : _mav_validator }, + 'mavcolors' : { 'Default' : None, + 'Description' : 'color cycle for moving averages (list or tuple of colors)'+ + '(overrides mpf style mavcolors).', + 'Validator' : lambda value: isinstance(value,(list,tuple)) and + all([mcolors.is_color_like(v) for v in value]) }, + 'renko_params' : { 'Default' : dict(), 'Description' : 'dict of renko parameters; call `mpf.kwarg_help("renko_params")`', 'Validator' : lambda value: isinstance(value,dict) }, @@ -184,6 +194,10 @@ def _valid_plot_kwargs(): 'axtitle' : { 'Default' : None, # Axes Title (subplot title) 'Description' : 'Axes Title (subplot title)', 'Validator' : lambda value: isinstance(value,(str,dict)) }, + + 'xlabel' : { 'Default' : None, # x-axis label + 'Description' : 'label for x-axis of plot', + 'Validator' : lambda value: isinstance(value,str) }, 'ylabel' : { 'Default' : 'Price', # y-axis label 'Description' : 'label for y-axis of main plot', @@ -450,6 +464,13 @@ def plot( data, **kwargs ): else: raise TypeError('style should be a `dict`; why is it not?') + if config['mavcolors'] is not None: + config['_ma_color_cycle'] = cycle(config['mavcolors']) + elif style['mavcolors'] is not None: + config['_ma_color_cycle'] = cycle(style['mavcolors']) + else: + config['_ma_color_cycle'] = None + if not external_axes_mode: fig = plt.figure() _adjust_figsize(fig,config) @@ -528,8 +549,10 @@ def plot( data, **kwargs ): if ptype in VALID_PMOVE_TYPES: mavprices = _plot_mav(axA1,config,xdates,pmove_avgvals) + emaprices = _plot_ema(axA1, config, xdates, pmove_avgvals) else: mavprices = _plot_mav(axA1,config,xdates,closes) + emaprices = _plot_ema(axA1, config, xdates, closes) avg_dist_between_points = (xdates[-1] - xdates[0]) / float(len(xdates)) if not config['tight_layout']: @@ -595,6 +618,13 @@ def plot( data, **kwargs ): else: for jj in range(0,len(mav)): retdict['mav' + str(mav[jj])] = mavprices[jj] + if config['ema'] is not None: + ema = config['ema'] + if len(ema) != len(emaprices): + warnings.warn('len(ema)='+str(len(ema))+' BUT len(emaprices)='+str(len(emaprices))) + else: + for jj in range(0, len(ema)): + retdict['ema' + str(ema[jj])] = emaprices[jj] retdict['minx'] = minx retdict['maxx'] = maxx retdict['miny'] = miny @@ -649,10 +679,12 @@ def plot( data, **kwargs ): xrotation = config['xrotation'] if not external_axes_mode: - _set_ticks_on_bottom_panel_only(panels,formatter,rotation=xrotation) + _set_ticks_on_bottom_panel_only(panels,formatter,rotation=xrotation, + xlabel=config['xlabel']) else: axA1.tick_params(axis='x',rotation=xrotation) axA1.xaxis.set_major_formatter(formatter) + axA1.set_xlabel(config['xlabel']) ysd = config['yscale'] if isinstance(ysd,dict): @@ -701,8 +733,8 @@ def plot( data, **kwargs ): elif panid == 'lower': panid = 1 # for backwards compatibility if apdict['y_on_right'] is not None: panels.at[panid,'y_on_right'] = apdict['y_on_right'] - aptype = apdict['type'] + if aptype == 'ohlc' or aptype == 'candle': ax = _addplot_collections(panid,panels,apdict,xdates,config) _addplot_apply_supplements(ax,apdict,xdates) @@ -1070,6 +1102,11 @@ def _addplot_columns(panid,panels,ydata,apdict,xdates,config): def _addplot_apply_supplements(ax,apdict,xdates): if (apdict['ylabel'] is not None): ax.set_ylabel(apdict['ylabel']) + # Note that xlabel is NOT supported for addplot. This is because + # in Panels Mode, there is only one xlabel (on the bottom axes) + # which is handled by the `xlabel` kwarg of `mpf.plot()`, + # whereas in External Axes Mode, users can call `Axes.set_xlabel()` on + # the axes object of their choice. if apdict['ylim'] is not None: ax.set_ylim(apdict['ylim'][0],apdict['ylim'][1]) if apdict['title'] is not None: @@ -1129,10 +1166,7 @@ def _plot_mav(ax,config,xdates,prices,apmav=None,apwidth=None): if len(mavgs) > 7: mavgs = mavgs[0:7] # take at most 7 - if style['mavcolors'] is not None: - mavc = cycle(style['mavcolors']) - else: - mavc = None + mavc = config['_ma_color_cycle'] for idx,mav in enumerate(mavgs): mean = pd.Series(prices).rolling(mav).mean() @@ -1147,6 +1181,42 @@ def _plot_mav(ax,config,xdates,prices,apmav=None,apwidth=None): mavp_list.append(mavprices) return mavp_list + +def _plot_ema(ax,config,xdates,prices,apmav=None,apwidth=None): + '''ema: exponential moving average''' + style = config['style'] + if apmav is not None: + mavgs = apmav + else: + mavgs = config['ema'] + mavp_list = [] + if mavgs is not None: + shift = None + if isinstance(mavgs,dict): + shift = mavgs['shift'] + mavgs = mavgs['period'] + if isinstance(mavgs,int): + mavgs = mavgs, # convert to tuple + if len(mavgs) > 7: + mavgs = mavgs[0:7] # take at most 7 + + mavc = config['_ma_color_cycle'] + + for idx,mav in enumerate(mavgs): + # mean = pd.Series(prices).rolling(mav).mean() + mean = pd.Series(prices).ewm(span=mav,adjust=False).mean() + if shift is not None: + mean = mean.shift(periods=shift[idx]) + emaprices = mean.values + lw = config['_width_config']['line_width'] + if mavc: + ax.plot(xdates, emaprices, linewidth=lw, color=next(mavc)) + else: + ax.plot(xdates, emaprices, linewidth=lw) + mavp_list.append(emaprices) + return mavp_list + + def _auto_secondary_y( panels, panid, ylo, yhi ): # If mag(nitude) for this panel is not yet set, then set it # here, as this is the first ydata to be plotted on this panel: @@ -1165,7 +1235,7 @@ def _auto_secondary_y( panels, panid, ylo, yhi ): def _valid_addplot_kwargs(): - valid_linestyles = ('-','solid','--','dashed','-.','dashdot','.','dotted',None,' ','') + valid_linestyles = ('-','solid','--','dashed','-.','dashdot',':','dotted',None,' ','') valid_types = ('line','scatter','bar', 'ohlc', 'candle','step') valid_stepwheres = ('pre','post','mid') valid_edgecolors = ('face', 'none', None) diff --git a/tests/reference_images/ema01.png b/tests/reference_images/ema01.png new file mode 100644 index 00000000..e21f3921 Binary files /dev/null and b/tests/reference_images/ema01.png differ diff --git a/tests/reference_images/ema02.png b/tests/reference_images/ema02.png new file mode 100644 index 00000000..5b8807f5 Binary files /dev/null and b/tests/reference_images/ema02.png differ diff --git a/tests/reference_images/ema03.png b/tests/reference_images/ema03.png new file mode 100644 index 00000000..561b02d2 Binary files /dev/null and b/tests/reference_images/ema03.png differ diff --git a/tests/test_ema.py b/tests/test_ema.py new file mode 100644 index 00000000..f691e4fd --- /dev/null +++ b/tests/test_ema.py @@ -0,0 +1,124 @@ +import os +import os.path +import glob +import mplfinance as mpf +import pandas as pd +import matplotlib.pyplot as plt +from matplotlib.testing.compare import compare_images + +print('mpf.__version__ =',mpf.__version__) # for the record +print('mpf.__file__ =',mpf.__file__) # for the record +print("plt.rcParams['backend'] =",plt.rcParams['backend']) # for the record + +base='ema' +tdir = os.path.join('tests','test_images') +refd = os.path.join('tests','reference_images') + +globpattern = os.path.join(tdir,base+'*.png') +oldtestfiles = glob.glob(globpattern) +for fn in oldtestfiles: + try: + os.remove(fn) + except: + print('Error removing file "'+fn+'"') + +IMGCOMP_TOLERANCE = 10.0 # this works fine for linux +# IMGCOMP_TOLERANCE = 11.0 # required for a windows pass. (really 10.25 may do it). + +_df = pd.DataFrame() +def get_ema_data(): + global _df + if len(_df) == 0: + _df = pd.read_csv('./examples/data/yahoofinance-GOOG-20040819-20180120.csv', + index_col='Date',parse_dates=True) + return _df + + +def create_ema_image(tname): + + df = get_ema_data() + df = df[-50:] # show last 50 data points only + + ema25 = df['Close'].ewm(span=25.0, adjust=False).mean() + mav25 = df['Close'].rolling(window=25).mean() + + ap = [ + mpf.make_addplot(df, panel=1, type='ohlc', color='c', + ylabel='mpf mav', mav=25, secondary_y=False), + mpf.make_addplot(ema25, panel=2, type='line', width=2, color='c', + ylabel='calculated', secondary_y=False), + mpf.make_addplot(mav25, panel=2, type='line', width=2, color='blue', + ylabel='calculated', secondary_y=False) + ] + + # plot and save in `tname` path + mpf.plot(df, ylabel="mpf ema", type='ohlc', + ema=25, addplot=ap, panel_ratios=(1, 1), savefig=tname + ) + + +def test_ema01(): + + fname = base+'01.png' + tname = os.path.join(tdir,fname) + rname = os.path.join(refd,fname) + + create_ema_image(tname) + + tsize = os.path.getsize(tname) + print(glob.glob(tname),'[',tsize,'bytes',']') + + rsize = os.path.getsize(rname) + print(glob.glob(rname),'[',rsize,'bytes',']') + + result = compare_images(rname,tname,tol=IMGCOMP_TOLERANCE) + if result is not None: + print('result=',result) + assert result is None + +def test_ema02(): + fname = base+'02.png' + tname = os.path.join(tdir,fname) + rname = os.path.join(refd,fname) + + df = get_ema_data() + df = df[-125:-35] + + mpf.plot(df, type='candle', ema=(5,15,25), mav=(5,15,25), savefig=tname) + + tsize = os.path.getsize(tname) + print(glob.glob(tname),'[',tsize,'bytes',']') + + rsize = os.path.getsize(rname) + print(glob.glob(rname),'[',rsize,'bytes',']') + + result = compare_images(rname,tname,tol=IMGCOMP_TOLERANCE) + if result is not None: + print('result=',result) + assert result is None + +def test_ema03(): + fname = base+'03.png' + tname = os.path.join(tdir,fname) + rname = os.path.join(refd,fname) + + df = get_ema_data() + df = df[-125:-35] + + mac = ['red','orange','yellow','green','blue','purple'] + + mpf.plot(df, type='candle', ema=(5,10,15,25), mav=(5,15,25), + mavcolors=mac, savefig=tname) + + + tsize = os.path.getsize(tname) + print(glob.glob(tname),'[',tsize,'bytes',']') + + rsize = os.path.getsize(rname) + print(glob.glob(rname),'[',rsize,'bytes',']') + + result = compare_images(rname,tname,tol=IMGCOMP_TOLERANCE) + if result is not None: + print('result=',result) + assert result is None +