start_date, end_date, bdpy = '2020-01-01', '2021-08-01', 360  # ' bdpy ' stands for 'business days per year'
maws = [10, 30, 60]  # ' maws ' stands for 'moving average windows'
rsiw = 14
rsi_method = "Wilder"  # "SMA", "EMA", "Wilder"
ric_list = ['KO.N', 'VOD.L']

        
        Copy
    

    	
            
from datetime import datetime
from dateutil.relativedelta import relativedelta  # '2.8.1'
import numpy  # '1.18.2'
import statistics
import pandas  # '1.2.4'
pandas.set_option('display.max_columns', None) # This allows us to see all the collumns of our dataframe

        
        Copy
    

    	
            
import eikon as ek
# The key is placed in a text file so that it may be used in this code without showing it itself:
eikon_key = open("eikon.txt", "r")
ek.set_app_key(str(eikon_key.read()))
# It is best to close the files we opened in order to make sure that we don't stop any other services/programs from accessing them if they need to:
eikon_key.close()

        
        Copy
    

    	
            
df1, err = ek.get_data(
    instruments=ric_list,
    fields=['TR.PriceClose.date', 'TR.PriceOpen', 'TR.PriceClose', 'TR.VOlume'],  # could also have TR.RSISimple30D & TR.RSISimple14D
    parameters={'SDate': start_date, 'EDate': end_date})

        
        Copy
    

    	
            
# Step 1: Create a list of days ranging throughout our period.
# The reason we look at every day is because some securities might trade on Sunday (e.g.: in middle-east)
delta = datetime.strptime(end_date, '%Y-%m-%d') - datetime.strptime(start_date, '%Y-%m-%d')
days = [datetime.strptime(start_date, '%Y-%m-%d') + relativedelta(days=i)
        for i in range(delta.days + 1)]
 
# Step 2: Create a pandas data-frame to populate with a loop
df2 = pandas.DataFrame(index=days)
 
# Step 3: Create a loop to populate our 'df' dataframe
# for m, i in enumerate(ric_list):
for i in ric_list:
 
    # get Close Prices: (You may use any way to collect such data, here we are recycling previous data)
    _df = pandas.DataFrame(
        data=[float(j) for j in df1[df1["Instrument"] == i]["Price Close"]],
        columns=[f"{i} Close"],
        index=[datetime.strptime(df1[df1["Instrument"] == i]["Date"][j],
                                 '%Y-%m-%dT%H:%M:%SZ')
               for j in list(df1[df1["Instrument"] == i]["Date"].index)])
 
    # get ln (logarithme naturel) return from Close Prices:
    _df[f"{i}'s ln Return"] = numpy.log(
        _df[f"{i} Close"] / _df[i + " Close"].shift(1))
 
    # get 1st difference in Close Prices:
    dCP = list((_df[f"{i} Close"] - _df[f"{i} Close"].shift(1)))
#     dCP.insert(0, numpy.nan)
    # list.reverse(dCP)
    _df[f"{i}'s 1d Close"] = dCP
 
    for j in maws:
        # get Close Price's 10, 30 and 60 Day Moving Averages
        _df[f"{i}'s Close {str(j)}D MA"] = _df[f"{i} Close"].dropna().rolling(j).mean()
 
        # get Close Price's ln Return 10, 30 and 60 Day Moving Average
        _df[f"{i}'s ln Return' {str(j)}D MA"] = _df[f"{i}'s ln Return"].dropna().rolling(j).mean()
#         # You may also want to look into TA-lib's Simple Moving Average function:
#         _df[i + "'s ln Return' " + str(j) + " Day Moving Average"] = ta.SMA(_df[i + " Close"], j)
 
        # get Annualised Standard Deviation (i.e.: volatility) of the 10, 30 and 60 Day Rolling Window (Natural Log) Returns (based on CLOSE prices)
        _df[f"{i}'s Ann. S.D. of {str(j)}D Roll. of ln Returns"] = _df[f"{i}'s ln Return"].dropna().rolling(j).std()*(bdpy**0.5)
 
 
    # RSI: Simple Moving Average
    if rsi_method == "SMA" or rsi_method == "Cutler":
        RSIw = []
        for k in range(len(dCP) - rsiw):
            up_moves, down_moves = [], []
            for j in range(k, k + rsiw):
                up_moves.append(max(dCP[j + 1], 0))  # ' + 1 ' because we're looking at 1st difference data, the 1st element of which is always nan.
                down_moves.append(abs(min(dCP[j + 1], 0)))   # ' + 1 ' because we're looking at 1st difference data, the 1st element of which is always nan.
            AvgU = statistics.mean(up_moves)
            AvgD = statistics.mean(down_moves)
            if AvgD == 0:
                RSIw.append(100)
            else:
                RSw = AvgU/AvgD
                RSIw.append(100-(100/(1+RSw)))
    # RSI: Exponential Moving Average
    if rsi_method == "EMA" or rsi_method == "MEMA" or rsi_method == "Wilder":
        if rsi_method == "MEMA" or rsi_method == "Wilder":
            a = 1 / rsiw
        elif rsi_method == "EMA":
            a = 2 / (rsiw + 1)
        RSIw, up_moves, down_moves = [], [], []
        for k in dCP[1:]:  # ' [1:] ' because we're looking at 1st difference data, the 1st element of which is always nan.
            up_moves.append(max(k, 0))
            down_moves.append(abs(min(k, 0)))
        AvgU = [statistics.mean(up_moves[0:rsiw])]
        AvgD = [statistics.mean(down_moves[0:rsiw])]
        if AvgD[0] == 0:
            RSIw.append(100)
        else:
            RSw = AvgU[0] / AvgD[0]
            RSIw.append(100 - (100 / (1 + RSw)))
        for k in range(rsiw, len(up_moves)):
            AvgU.append(a * up_moves[k] + (1 - a) * AvgU[k - rsiw])
            AvgD.append(a * down_moves[k] + (1 - a) * AvgD[k - rsiw])
            RSw = AvgU[k - rsiw] / AvgD[k - rsiw]
            RSIw.append(100 - (100 / (1 + RSw)))
    RSIw.append(numpy.nan)  # This is needed to inser the nan from the 1st difference that was already nan
    for k in range(len(_df.index) - len(RSIw)):
        RSIw.insert(0, numpy.nan)
    _df[f"{i}'s RSI{rsiw}"] = RSIw
 
    # Finally: merge all.
    df2 = pandas.merge(
        df2, _df, how="outer", left_index=True, right_index=True)

        
        Copy
    

    	
            
import plotly
import plotly.express
from plotly.graph_objs import *
from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot
init_notebook_mode(connected=True)
import cufflinks
cufflinks.go_offline()

        
        Copy
    

    	
            
df2["KO.N's RSI14"].dropna().iplot(title="KO.N's Wilder RSI14",
                                   colors="#001EFF", theme="solar")

        
        Copy
    

    	
            
def Refinitiv_RSI(start_date='2020-01-01', end_date='2021-08-01', bdpy=360,  # ' bdpy ' stands for 'business days per year'
                  maws=[10, 30, 60],  # ' maws ' stands for 'moving average windows'
                  rsiw=14, rsi_method="Wilder",  # "SMA", "EMA", "Wilder"
                  ric_list=['KO.N', 'VOD.L']):
    """Refinitiv_RSI(start_date='2020-01-01', end_date='2021-08-01', bdpy=360, maws=[10, 30, 60], rsiw=14, rsi_method="Wilder", ric_list=['KO.N', 'VOD.L']) Version 1.0
    This Python function returns the close prices of instruments asked for and
    calculates their (i) Natural Log Returns, (ii) 1st Difference,
    (iii) Moving Averages, (iv)Natural Log Returns' Moving Averages,
    (v) Annual Standard Deviations of a Rolling window of Natural Log Returns,
    and (vi) Relative Strength Indices
 
    Dependencies
    ----------
 
    Python library 'eikon' version 1.1.8
    Python library 'numpy' version 1.18.2
    Python library 'statistics'
    Python library 'pandas' version 1.2.4
 
    As well as the:
 
    Python library 'datetime' from 'datetime'. Imported via following line:
    >>> from datetime import datetime
 
    Python sub-library 'dateutil.relativedelta' version 2.8.1 from 'relativedelta'. Imported via following line:
    >>> from dateutil.relativedelta import relativedelta
 
    Parameters
    ----------
 
    start_date: str
        The starting date in the format '%Y-%m-%d'.
        Default: start_date='2020-01-01'.
 
    end_date: str
        The end date in the format '%Y-%m-%d'.
        Default: start_date='2021-08-01'.
 
    bdpy: int
        ' bdpy ' stands for 'business days per year'
        Default: bdpy=360.
 
    maws: list
        List of integers of the moving average windows asked for.
        Default: maws=[10, 30, 60].
 
    rsiw: int
        Relative Strength Index window
        Default: rsiw=14.
 
    rsi_method: str
        To choose from "SMA" for 'Simple Moving Average, "EMA" for 'Exponential Moving Average', or "Wilder".
        Default: rsi_method="Wilder".
 
    ric_list: list
        List of strings of RICs of instruments for which data is requested.
        Default: ric_list=['KO.N', 'VOD.L'].
 
 
    Returns
    -------
 
    Pandas data-frame
    """
 
    df1, err = ek.get_data(
        instruments=ric_list,
        fields=['TR.PriceClose.date', 'TR.PriceOpen', 'TR.PriceClose', 'TR.VOlume'],  # could also have TR.RSISimple30D & TR.RSISimple14D
        parameters={'SDate': start_date, 'EDate': end_date})
 
    # Step 1: Create a list of days ranging throughout our period.
    # The reason we look at every day is because some securities might trade on Sunday (e.g.: in middle-east)
    delta = datetime.strptime(end_date, '%Y-%m-%d') - datetime.strptime(start_date, '%Y-%m-%d')
    days = [datetime.strptime(start_date, '%Y-%m-%d') + relativedelta(days=i)
            for i in range(delta.days + 1)]
 
    # Step 2: Create a pandas data-frame to populate with a loop
    df2 = pandas.DataFrame(index=days)
 
    # Step 3: Create a loop to populate our 'df' dataframe
    # for m, i in enumerate(ric_list):
    for i in ric_list:
 
        # get Close Prices: (You may use any way to collect such data, here we are recycling previous data)
        _df = pandas.DataFrame(
            data=[float(j) for j in df1[df1["Instrument"] == i]["Price Close"]],
            columns=[f"{i} Close"],
            index=[datetime.strptime(df1[df1["Instrument"] == i]["Date"][j],
                                     '%Y-%m-%dT%H:%M:%SZ')
                   for j in list(df1[df1["Instrument"] == i]["Date"].index)])
 
        # get ln (logarithme naturel) return from Close Prices:
        _df[f"{i}'s ln Return"] = numpy.log(
            _df[f"{i} Close"] / _df[i + " Close"].shift(1))
 
        # get 1st difference in Close Prices:
        dCP = list((_df[f"{i} Close"] - _df[f"{i} Close"].shift(1)))
        # list.reverse(dCP)
        _df[f"{i}'s 1d Close"] = dCP
 
        for j in maws:
            # get Close Price's 10, 30 and 60 Day Moving Averages
            _df[f"{i}'s Close {str(j)}D MA"] = _df[f"{i} Close"].dropna().rolling(j).mean()
 
            # get Close Price's ln Return 10, 30 and 60 Day Moving Average
            _df[f"{i}'s ln Return' {str(j)}D MA"] = _df[f"{i}'s ln Return"].dropna().rolling(j).mean()
#             # You may also want to look into TA-lib's Simple Moving Average function:
#             _df[i + "'s ln Return' " + str(j) + " Day Moving Average"] = ta.SMA(_df[i + " Close"], j)
 
            # get Annualised Standard Deviation (i.e.: volatility) of the 10, 30 and 60 Day Rolling Window (Natural Log) Returns (based on CLOSE prices)
            _df[f"{i}'s Ann. S.D. of {str(j)}D Roll. of ln Returns"] = _df[f"{i}'s ln Return"].dropna().rolling(j).std()*(bdpy**0.5)
 
 
        # RSI: Simple Moving Average
        if rsi_method == "SMA" or rsi_method == "Cutler":
            RSIw = []
            for k in range(len(dCP) - rsiw):
                up_moves, down_moves = [], []
                for j in range(k, k + rsiw):
                    up_moves.append(max(dCP[j + 1], 0))  # ' + 1 ' because we're looking at 1st difference data, the 1st element of which is always nan.
                    down_moves.append(abs(min(dCP[j + 1], 0)))   # ' + 1 ' because we're looking at 1st difference data, the 1st element of which is always nan.
                AvgU = statistics.mean(up_moves)
                AvgD = statistics.mean(down_moves)
                if AvgD == 0:
                    RSIw.append(100)
                else:
                    RSw = AvgU/AvgD
                    RSIw.append(100-(100/(1+RSw)))
        # RSI: Exponential Moving Average
        if rsi_method == "EMA" or rsi_method == "MEMA" or rsi_method == "Wilder":
            if rsi_method == "MEMA" or rsi_method == "Wilder":
                a = 1 / rsiw
            elif rsi_method == "EMA":
                a = 2 / (rsiw + 1)
            RSIw, up_moves, down_moves = [], [], []
            for k in dCP[1:]:  # ' [1:] ' because we're looking at 1st difference data, the 1st element of which is always nan.
                up_moves.append(max(k, 0))
                down_moves.append(abs(min(k, 0)))
            AvgU = [statistics.mean(up_moves[0:rsiw])]
            AvgD = [statistics.mean(down_moves[0:rsiw])]
            if AvgD[0] == 0:
                RSIw.append(100)
            else:
                RSw = AvgU[0] / AvgD[0]
                RSIw.append(100 - (100 / (1 + RSw)))
            for k in range(rsiw, len(up_moves)):
                AvgU.append(a * up_moves[k] + (1 - a) * AvgU[k - rsiw])
                AvgD.append(a * down_moves[k] + (1 - a) * AvgD[k - rsiw])
                RSw = AvgU[k - rsiw] / AvgD[k - rsiw]
                RSIw.append(100 - (100 / (1 + RSw)))
        RSIw.append(numpy.nan)  # This is needed to inser the nan from the 1st difference that was already nan
        for k in range(len(_df.index) - len(RSIw)):
            RSIw.insert(0, numpy.nan)
        _df[f"{i}'s RSI{rsiw}"] = RSIw
 
        # Finally: merge all.
        return pandas.merge(df2, _df, how="outer", left_index=True, right_index=True)

        
        Copy
    

    	
            df = Refinitiv_RSI(ric_list=['MSFT.O'])
        
        Copy
    

    	
            df.dropna()
        
        Copy
    

    	
            
df["MSFT.O's RSI14"].dropna().iplot(title="MSFT.O's Wilder RSI14",
                                    colors="#001EFF", theme="solar")

        
        Copy