goldhand 15.4__py3-none-any.whl → 15.7__py3-none-any.whl

goldhand/backtest.py

@@ -6,6 +6,15 @@ import plotly.express as px
 
 class Backtest:
     def __init__(self, data, strategy_function, plot_title='', **kwargs):
+        """
+        Backtest class to test strategies on historical data to see how they would have performed.
+        
+        Parameters:
+        - data: pandas DataFrame with historical data
+        - strategy_function: function that takes in the data and returns a DataFrame of trades
+        - plot_title: title for the plot
+        - kwargs: additional parameters to be passed to the strategy function
+        """
         self.data = data
         self.plot_title = plot_title
         self.strategy_function = strategy_function
@@ -15,6 +24,9 @@ class Backtest:
 
 
     def add_trades(self):
+        """
+        Calculate the trades using the strategy function and the data provided
+        """
         self.trades = self.strategy_function(self.data, **self.additional_params)
         self.trades['ticker'] = self.data['ticker'].iloc[0]
         
@@ -26,6 +38,9 @@ class Backtest:
 
 
     def summary_of_trades(self):
+        """
+        Calculate the summary of the trades
+        """
         self.trades_summary = {
           'ticker' : self.data['ticker'].iloc[0],
           'number_of_trades' : self.trades.shape[0],
@@ -57,12 +72,20 @@ class Backtest:
           'max_gain(%)' : round(((self.trades['result'].max()-1)*100),2),
           'max_lost(%)' : round(((self.trades['result'].min()-1)*100),2),
 
-          'first_trade_buy' : min(self.trades['buy_date'])
+          'first_trade_buy' : min(self.trades['buy_date']),
+          'first_close_price' : self.data['close'].iloc[0],
+          'first_date' : self.data['date'].iloc[0],
+          'last_price' : self.data['close'].iloc[-1],
+          'hold_result' : round(((self.data['close'].iloc[-1] / self.data['close'].iloc[0])-1)*100,2)
+          
 
         }
         self.trades_summary.update(self.additional_params)
 
     def show_trades(self):
+        """
+        Plot the trades of the strategy on the data provided
+        """
         tdf = self.data
         fig = go.Figure(data=go.Ohlc(x=tdf['date'], open=tdf['open'], high=tdf['high'], low=tdf['low'],close=tdf['close']))
         fig.add_trace( go.Scatter(x=tdf['date'], y=tdf['sma_50'], opacity =0.5, line=dict(color='lightblue', width = 2) , name = 'SMA 50') )
@@ -116,6 +139,12 @@ class Backtest:
 
 
     def summarize_strategy(self):
+        """
+        Display the summary of the strategy:
+        - Summary of trades
+        - Trades in interactive plot
+        - Trades in DataFrame
+        """
         display(pd.DataFrame(self.trades_summary, index=['Strategy summary']).T )
         self.show_trades().show()
         display(self.trades)

goldhand/stocks.py

@@ -11,6 +11,15 @@ import cloudscraper
 
 class GoldHand:
     def __init__(self, ticker, ad_ticker=True, range='18y', interval='1d'):
+        """
+        GoldHand class to download and analyze stock data
+
+        Paramseters:
+        - ticker: str, ticker symbol of the stocks or crypto or ETF
+        - ad_ticker: bool, add ticker column to the DataFrame
+        - range: str, time range to download data for example 5y,1y, 1mo, 1d, 1h
+        - interval: str, interval to download data for example 1d, 1h, 5m
+        """
         self.scraper = cloudscraper.create_scraper()
         self.ad_ticker = ad_ticker
         self.range = range
@@ -22,7 +31,8 @@ class GoldHand:
 
     def get_olhc(self):
         """
-        Download historical stock data for the last year
+        Download historical stock, crypto or ETF data from yahoo finance
+        API documentation location: https://cryptocointracker.com/yahoo-finance/yahoo-finance-api
         """
         #scraper = cloudscraper.create_scraper()
         response = self.scraper.get(f"https://query1.finance.yahoo.com/v8/finance/chart/{self.ticker}?interval={self.interval}&range={self.range}")
@@ -36,7 +46,13 @@ class GoldHand:
     
     def smma(self, data, window, colname):
         """
-        Calculate Smoothed Moving Average (SMMA)
+        Calculate Smoothed Simple Moving Average (SMMA)
+        Parameters:
+        - data: Pandas DataFrame
+        - window: int, window size
+        - colname: str, name of the column to add to the DataFrame
+        
+        Return: DataFrame with added column
         """
         hl2 = data['hl2'].values
         smma_values = [hl2[0]]
@@ -51,105 +67,119 @@ class GoldHand:
 
 
     def download_historical_data(self):
+        """
+        Download historical stock, crypto or ETF data 
+        """
         # Download historical stock data for the last year
         self.df = self.get_olhc()
         self.df.columns = self.df.columns.str.lower()
         self.df['hl2'] = (self.df['high'] + self.df['low'])/2
         
-        # Rsi
-        self.df['rsi'] = ta.rsi(self.df['close'], 14)
-
-        # SMAS
-        self.df['sma_50']= ta.sma(self.df['close'], 50)
-        self.df['diff_sma50'] = (self.df['close']/self.df['sma_50'] -1)*100
-        self.df['sma_100']= ta.sma(self.df['close'], 100)
-        self.df['diff_sma100'] = (self.df['close']/self.df['sma_100'] -1)*100
-        self.df['sma_200']= ta.sma(self.df['close'], 200)
-        self.df['diff_sma200'] = (self.df['close']/self.df['sma_200'] -1)*100
-
-        #Bolinger bands
-        bb = ta.bbands(self.df['close'])
-        bb.columns = ['bb_lower', 'bb_mid', 'bb_upper', 'bandwidth', 'percent']
-        self.df['bb_lower'] = bb['bb_lower']
-        self.df['bb_upper'] = bb['bb_upper']
-        self.df['diff_upper_bb'] = (self.df['bb_upper']/self.df['close'] -1)*100
-        self.df['diff_lower_bb'] = (self.df['bb_lower']/self.df['close'] -1)*100
-
-        #local min maxs
-        self.df['local'] = ''
-        self.df['local_text'] = ''
-        max_ids = list(argrelextrema(self.df['high'].values, np.greater, order=30)[0])
-        min_ids = list(argrelextrema(self.df['low'].values, np.less, order=30)[0])
-        self.df.loc[min_ids, 'local'] = 'minimum'
-        self.df.loc[max_ids, 'local'] = 'maximum'
-
-
-        states = self.df[self.df['local']!='']['local'].index.to_list()
-        problem = []
-        problem_list = []
-        for i in range(0, (len(states)-1) ):
-
-            if (self.df.loc[states[i], 'local'] != self.df.loc[states[i+1], 'local']):
-                if (len(problem)==0):
-                    continue
+        try:
+            # Rsi
+            self.df['rsi'] = ta.rsi(self.df['close'], 14)
+
+            # SMAS
+            self.df['sma_50']= ta.sma(self.df['close'], 50)
+            self.df['diff_sma50'] = (self.df['close']/self.df['sma_50'] -1)*100
+            self.df['sma_100']= ta.sma(self.df['close'], 100)
+            self.df['diff_sma100'] = (self.df['close']/self.df['sma_100'] -1)*100
+            self.df['sma_200']= ta.sma(self.df['close'], 200)
+            self.df['diff_sma200'] = (self.df['close']/self.df['sma_200'] -1)*100
+
+            #Bolinger bands
+            bb = ta.bbands(self.df['close'])
+            bb.columns = ['bb_lower', 'bb_mid', 'bb_upper', 'bandwidth', 'percent']
+            self.df['bb_lower'] = bb['bb_lower']
+            self.df['bb_upper'] = bb['bb_upper']
+            self.df['diff_upper_bb'] = (self.df['bb_upper']/self.df['close'] -1)*100
+            self.df['diff_lower_bb'] = (self.df['bb_lower']/self.df['close'] -1)*100
+
+            #local min maxs
+            self.df['local'] = ''
+            self.df['local_text'] = ''
+            max_ids = list(argrelextrema(self.df['high'].values, np.greater, order=30)[0])
+            min_ids = list(argrelextrema(self.df['low'].values, np.less, order=30)[0])
+            self.df.loc[min_ids, 'local'] = 'minimum'
+            self.df.loc[max_ids, 'local'] = 'maximum'
+
+
+            states = self.df[self.df['local']!='']['local'].index.to_list()
+            problem = []
+            for i in range(0, (len(states)-1) ):
+
+                if (self.df.loc[states[i], 'local'] != self.df.loc[states[i+1], 'local']):
+                    if (len(problem)==0):
+                        continue
+                    else:
+                        problem.append(states[i])
+                        text = self.df.loc[states[i], 'local']
+                        if(text=='minimum'):
+                            real_min = self.df.loc[problem, 'low'].idxmin()
+                            problem.remove(real_min)
+                            self.df.loc[problem, 'local']=''
+                        else:
+                            real_max = self.df.loc[problem, 'high'].idxmax()
+                            problem.remove(real_max)
+                            self.df.loc[problem, 'local']=''
+
+                        problem = []
                 else:
                     problem.append(states[i])
-                    text = self.df.loc[states[i], 'local']
-                    if(text=='minimum'):
-                        real_min = self.df.loc[problem, 'low'].idxmin()
-                        problem.remove(real_min)
-                        self.df.loc[problem, 'local']=''
-                    else:
-                        real_max = self.df.loc[problem, 'high'].idxmax()
-                        problem.remove(real_max)
-                        self.df.loc[problem, 'local']=''
-
-                    problem = []
-            else:
-                problem.append(states[i])
-
-        states = self.df[self.df['local']!='']['local'].index.to_list()
 
-        # if first is min ad the price
-        if self.df.loc[states[0], 'local']== 'minimum':
-            self.df.loc[states[0],'local_text'] = f"${round(self.df.loc[states[0], 'low'], 2)}"
-        else:
-            self.df.loc[states[0],'local_text'] = f"${round(self.df.loc[states[0], 'high'], 2)}"
+            states = self.df[self.df['local']!='']['local'].index.to_list()
 
-        # add last fall if last local is max
-        if list(self.df[self.df['local']!='']['local'])[-1]=='maximum':
-            last_min_id = self.df.loc[self.df['low']==min(self.df['low'][-3:] )].index.to_list()[0]
-            self.df.loc[last_min_id , 'local'] = 'minimum'
-
-        states = self.df[self.df['local']!='']['local'].index.to_list()
-        
-        
-        for i in range(1,len(states)):
-            prev = self.df.loc[states[i-1], 'local']
-            current= self.df.loc[states[i], 'local']
-            prev_high = self.df.loc[states[i-1], 'high']
-            prev_low = self.df.loc[states[i-1], 'low']
-            current_high = self.df.loc[states[i], 'high']
-            current_low = self.df.loc[states[i], 'low']
-            if current == 'maximum':
-                # rise
-                rise = (current_high/ prev_low -1)*100
-                if rise>100:
-                    self.df.loc[states[i], 'local_text'] = f'🚀🌌{round(((rise+100)/100), 2)}x<br>${round(current_high, 2)}'
-                else:
-                    self.df.loc[states[i], 'local_text'] = f'🚀{round(rise, 2)}%<br>${round(current_high, 2)}'
+            # if first is min ad the price
+            if self.df.loc[states[0], 'local']== 'minimum':
+                self.df.loc[states[0],'local_text'] = f"${round(self.df.loc[states[0], 'low'], 2)}"
             else:
-                fall = round((1-(current_low / prev_high))*100, 2)
-                if fall < 30:
-                    temj = '💸'
-                elif fall < 50:
-                    temj = '💸'
+                self.df.loc[states[0],'local_text'] = f"${round(self.df.loc[states[0], 'high'], 2)}"
+
+            # add last fall if last local is max
+            if list(self.df[self.df['local']!='']['local'])[-1]=='maximum':
+                last_min_id = self.df.loc[self.df['low']==min(self.df['low'][-3:] )].index.to_list()[0]
+                self.df.loc[last_min_id , 'local'] = 'minimum'
+
+            states = self.df[self.df['local']!='']['local'].index.to_list()
+            
+            
+            for i in range(1,len(states)):
+                prev = self.df.loc[states[i-1], 'local']
+                current= self.df.loc[states[i], 'local']
+                prev_high = self.df.loc[states[i-1], 'high']
+                prev_low = self.df.loc[states[i-1], 'low']
+                current_high = self.df.loc[states[i], 'high']
+                current_low = self.df.loc[states[i], 'low']
+                if current == 'maximum':
+                    # rise
+                    rise = (current_high/ prev_low -1)*100
+                    if rise>100:
+                        self.df.loc[states[i], 'local_text'] = f'🚀🌌{round(((rise+100)/100), 2)}x<br>${round(current_high, 2)}'
+                    else:
+                        self.df.loc[states[i], 'local_text'] = f'🚀{round(rise, 2)}%<br>${round(current_high, 2)}'
                 else:
-                    temj = '😭💔' 
-                self.df.loc[states[i], 'local_text'] = f'{temj}{fall}%<br>${round(current_low, 2)}'
-        self.df.reset_index(inplace=True, drop=True)
+                    fall = round((1-(current_low / prev_high))*100, 2)
+                    if fall < 30:
+                        temj = '💸'
+                    elif fall < 50:
+                        temj = '💸'
+                    else:
+                        temj = '😭💔' 
+                    self.df.loc[states[i], 'local_text'] = f'{temj}{fall}%<br>${round(current_low, 2)}'
+            self.df.reset_index(inplace=True, drop=True)
+        except:
+            pass
 
     def plotly_last_year(self, plot_title, plot_height=900, ndays=500, ad_local_min_max=True):
+        """
+        Plot last year interactive plot of a stock analyzing the local minimums and maximums
+        Parameters:
+        - plot_title: str, title of the plot
+        - plot_height: int, height of the plot
+        - ndays: int, number of days to plot
+        - ad_local_min_max: bool, add local min max to the plot
+        Return: plotly figure
+        """
         tdf = self.df.tail(ndays)
 
         fig = go.Figure(data=go.Ohlc(x=tdf['date'], open=tdf['open'], high=tdf['high'], low=tdf['low'],close=tdf['close']))
@@ -176,6 +206,15 @@ class GoldHand:
         return(fig)
 
     def plot_goldhand_line(self, plot_title, plot_height=900, ndays=800,  ad_local_min_max=True):
+        """
+        Plot last year interactive plot of a stock analyzing the local minimums and maximums using the GoldHandLine indicator
+        Parameters:
+        - plot_title: str, title of the plot
+        - plot_height: int, height of the plot
+        - ndays: int, number of days to plot
+        - ad_local_min_max: bool, add local min max to the plot
+        Return: plotly figure
+        """
         
         data = self.df.copy()
         # Apply SMMA to the dataframe

goldhand/strategy_goldhand_line.py

@@ -10,13 +10,14 @@ from goldhand import *
 
 def goldhand_line_strategy(data, buy_at='gold', sell_at='grey'):
     """
-    This function implements the goldhand line strategy.
+    This function implements the GoldHandLine strategy.
+    
     Parameters:
-    data (pandas.DataFrame): The dataframe containing the data.
-    buy_at (str): The color of the line to buy at. Default is 'gold'.
-    sell_at (str): The color of the line to sell at. Default is 'grey'.
-    Returns:
-    res_df (pandas.DataFrame): The dataframe containing the results.
+    - data (pandas DataFrame) : The DataFrame containing the data.
+    - buy_at (str): The color of the line to buy at. Default is 'gold'.
+    - sell_at (str): The color of the line to sell at. Default is 'grey'.
+    
+    Returns: The trades of the GoldHandLine strategy. 
     """
 
     data['hl2'] = (data['high'] + data['low'])/2
@@ -112,15 +113,18 @@ def goldhand_line_strategy(data, buy_at='gold', sell_at='grey'):
 
 def show_indicator_goldhand_line_strategy(ticker, plot_title = '', buy_at='gold', sell_at='grey', ndays=0, plot_height=1000, add_strategy_summary = True):
     """
-    This function shows the goldhand line strategy on a plotly candlestick chart.   
+    This function shows the GoldHandLine strategy on a plotly chart including the price,  trades, strategy summary and GoldHandLine indicator.
+       
     Parameters:
-    ticker (str): The ticker of the stock or ETF.
-    plot_title (str): The title of the plot.
-    ndays (int): The number of days to show. If 0, all data will be shown.
-    plot_height (int): The height of the plot.
-    add_strategy_summary (bool): If True, the strategy summary will be added to the plot.
-    Returns:
-    fig (plotly.graph_objects.Figure): The plotly figure.
+    - ticker (str): The ticker of the stock or crypto or ETF.
+    - plot_title (str): The title of the plot.
+    - buy_at (str): The color of the line to buy at. Default is 'gold'.
+    - sell_at (str): The color of the line to sell at. Default is 'grey'.
+    - ndays (int): The number of days to show. If 0, all data will be shown.
+    - plot_height (int): The height of the plot.
+    - add_strategy_summary (bool): If True, the strategy summary will be added to the plot.
+    
+    Returns: The plot including the price,  trades, strategy summary and GoldHandLine indicator.
     """
 
     data = GoldHand(ticker).df
@@ -159,10 +163,10 @@ def show_indicator_goldhand_line_strategy(ticker, plot_title = '', buy_at='gold'
     # Create a 'group' column and increase the value only when there's a color change
     data['group'] = (data['color_change']).cumsum()
 
-    ##### data prepar end
+    ##### data preparation end
 
     ##### backtest
-    backtest = Backtest( data, goldhand_line_strategy, plot_title =plot_title, buy_at='gold', sell_at='grey')
+    backtest = Backtest( data, goldhand_line_strategy, plot_title =plot_title, buy_at= buy_at, sell_at=sell_at)
     trades =backtest.trades
 
     if ndays!=0:

goldhand/strategy_rsi.py

@@ -9,6 +9,14 @@ from goldhand import *
 
 
 def rsi_strategy(data, buy_threshold = 30, sell_threshold = 70):
+    """
+    RSI strategy for backtesting with Backtest class
+    
+    Parameters:
+    - data: pandas DataFrame with columns: date, open, high, low, close, volume and rsi
+    - buy_threshold: int, default 30,  buy when RSI is below this value
+    - sell_threshold: int, default 70, sell when RSI is above this value
+    """
 
     in_trade = False  # Flag to track if already in a trade
     trade_id = 1
@@ -78,6 +86,17 @@ def rsi_strategy(data, buy_threshold = 30, sell_threshold = 70):
 
 
 def show_indicator_rsi_strategy(ticker, buy_threshold = 30, sell_threshold = 70, plot_title = '', ndays=0, plot_height=1000, add_strategy_summary = True):
+    """
+    Show RSI strategy result in one plot: candlestick chart, SMA lines, trades, RSI indicator, summary of the strategy on the left side of the plot
+    Parameters:
+    - ticker: str, ticker symbol
+    - buy_threshold: int, default 30,  buy when RSI is below this value
+    - sell_threshold: int, default 70, sell when RSI is above this value
+    - plot_title: str, default '', title of the plot
+    - ndays: int, default 0, number of days to show, if 0, show all data
+    - plot_height: int, default 1000, height of the plot
+    - add_strategy_summary: bool, default True, add strategy summary to the plot
+    """
 
     tdf = GoldHand(ticker).df
     backtest = Backtest( tdf, rsi_strategy, buy_threshold=buy_threshold, sell_threshold=sell_threshold)

goldhand/tw.py

@@ -9,13 +9,22 @@ import json
 
 class Tw:
     def __init__(self):
+        """ 
+        Get all stock, crypto and ETF data from TradingView
+        """
         self.stock = pd.DataFrame()
         self.crypto = pd.DataFrame()
+        self.etf = pd.DataFrame()
         
         self.get_all_stock()
         self.get_all_crypto()
+        self.get_all_etf()
 
     def get_all_stock(self):
+        """ 
+        Get all stocks data from TradingView
+        """
+        
         data_query = '{"filter":[{"left":"type","operation":"in_range","right":["stock","dr","fund"]},{"left":"subtype","operation":"in_range","right":["common","foreign-issuer","","etf","etf,odd","etf,otc","etf,cfd"]},{"left":"exchange","operation":"in_range","right":["AMEX","NASDAQ","NYSE"]},{"left":"is_primary","operation":"equal","right":true},{"left":"active_symbol","operation":"equal","right":true}],"options":{"lang":"en"},"markets":["america"],"symbols":{"query":{"types":[]},"tickers":[]},"columns":["logoid","name","close","change","change_abs","Recommend.All","volume","Value.Traded","market_cap_basic","price_earnings_ttm","earnings_per_share_basic_ttm","number_of_employees","sector","High.3M","Low.3M","Perf.3M","Perf.5Y","High.1M","Low.1M","High.6M","Low.6M","Perf.6M","beta_1_year","price_52_week_high","price_52_week_low","High.All","Low.All","BB.lower","BB.upper","change|1M","change_abs|1M","change|1W","change_abs|1W","change|240","country","EMA50","EMA100","EMA200","MACD.macd","MACD.signal","Mom","Perf.1M","RSI7","SMA50","SMA100","SMA200","Stoch.RSI.K","Stoch.RSI.D","Perf.W","Perf.Y","Perf.YTD","industry","Perf.All","description","type","subtype","update_mode","pricescale","minmov","fractional","minmove2","Mom[1]","RSI7[1]","Rec.Stoch.RSI","currency","fundamental_currency_code"],"sort":{"sortBy":"market_cap_basic","sortOrder":"desc"},"range":[0,8000]}'
         response = requests.post('https://scanner.tradingview.com/america/scan', data=data_query)
         data = response.json()
@@ -26,6 +35,10 @@ class Tw:
 
 
     def get_all_crypto(self):
+        """
+        Get all crypto data from TradingView       
+        """
+
         data_query = '{"columns":["base_currency","base_currency_desc","base_currency_logoid","update_mode","type","typespecs","exchange","crypto_total_rank","close","pricescale","minmov","fractional","minmove2","currency","24h_close_change|5","market_cap_calc","fundamental_currency_code","24h_vol_cmc","circulating_supply","crypto_common_categories","crypto_blockchain_ecosystems"],"ignore_unknown_fields":false,"options":{"lang":"en"},"range":[0,300],"sort":{"sortBy":"crypto_total_rank","sortOrder":"asc"},"markets":["coin"]}'
         response = requests.post('https://scanner.tradingview.com/coin/scan', data=data_query)
         data = response.json()
@@ -36,21 +49,53 @@ class Tw:
         self.crypto = self.crypto.loc[filter, ]
         self.crypto['ticker'] = self.crypto['base_currency'] + '-USD'
 
+    def get_all_etf(self):
+        """
+        Get all ETFs from TradingView
+        """
+        data_query = '{"columns":["name","description","logoid","update_mode","type","typespecs","close","pricescale","minmov","fractional","minmove2","currency","change","Value.Traded","relative_volume_10d_calc","aum","fundamental_currency_code","nav_total_return.5Y","expense_ratio","asset_class.tr","focus.tr","nav_discount_premium","category.tr","brand.tr","niche.tr"],"ignore_unknown_fields":false,"options":{"lang":"en"},"price_conversion":{"to_symbol":true},"range":[0,3000],"sort":{"sortBy":"aum","sortOrder":"desc"},"markets":["america"],"filter2":{"operator":"and","operands":[{"operation":{"operator":"or","operands":[{"operation":{"operator":"and","operands":[{"expression":{"left":"typespecs","operation":"has","right":["etn"]}}]}},{"operation":{"operator":"and","operands":[{"expression":{"left":"typespecs","operation":"has","right":["etf"]}}]}}]}}]}}'
+        response = requests.post('https://scanner.tradingview.com/america/scan', data=data_query)
+        data = response.json()
+        list_elements = list(map(lambda x:x['d'], data['data'] ))
+        self.etf = pd.DataFrame(list_elements)
+        self.etf.columns = json.loads(data_query)['columns']
+        self.etf = self.etf[self.etf['name'].str.contains('\\.')!=True]
+    
+    
+    def moneystring( self, money):
+        """
+        Convert money to string with unit
+        Parameters:
+        - money: money to convert
+        Return: string with unit
+        """
+
+        if money > 1_000_000_000_000:
+            money_str = f"{round(money / 1_000_000_000_000, 2)} Trillion" 
+        elif money>1_000_000_000:
+            money_str = f"{round(money / 1_000_000_000, 2)} Billion"
+        else:
+            money_str = f"{round(money / 1_000_000, 2)} Million"
+        return money_str
+
 
     def get_one_stock_info(self, ticker):
+        """
+        Get info about one stock
+        Parameters: 
+        - ticker: ticker of the stock
+        Return: type dictioanry
+        """
+
         ticker = ticker.upper()
         one_row = self.stock.loc[self.stock['name']==ticker,].iloc[0]
         tsec = self.stock.loc[self.stock['sector']==one_row['sector']].reset_index(drop=True)
         tind = self.stock.loc[self.stock['industry']== one_row['industry']].reset_index(drop=True)
-        if one_row['market_cap_basic'] <100_000_000:
-            market_cap = f"💲{round(one_row['market_cap_basic']/1_000_000, 2):,} Million"
-        else:
-            market_cap = f"💲{round(one_row['market_cap_basic']/1_000_000):,} Million"
         return({'ticker': one_row['name'],
                 'price': one_row['close'],
                 'market_cap': one_row['market_cap_basic'] ,
                 'n_emp': one_row['number_of_employees'],
-                'market_cap_text': market_cap,
+                'market_cap_text': self.moneystring(one_row['market_cap_basic']),
                 'name': one_row['description'],
                 'sector': one_row['sector'],
                 'industry': one_row['industry'],
@@ -61,66 +106,104 @@ class Tw:
         
         
     def get_top_n_stocks_by_sector(self,percent=10):
-        return( 
-               (
+        """
+        Get top n % stocks by sector
+        Parameters: 
+        - percent: percent of stocks to return
+        Return: Pandas DataFrame
+        """
+
+        return ( 
                 self.stock.groupby('sector')
                  .apply(lambda x: x.nlargest(int(len(x) * round((percent/100),2) ), 'market_cap_basic'))
                  .reset_index(drop=True)
-                )
+                
             )
-
+        
 
     def get_plotly_title(self, ticker):
+        """
+        Get plotly title for stock or crypto
+        Parameters: 
+        - ticker: ticker of the stock
+        Return: Summary of the stock or crypto to be used as plotly title
+        """
 
         if '-USD' in ticker:
+            # crypto
             coin = self.crypto.loc[self.crypto['ticker']==ticker].iloc[0]
-            plotly_title = f"{coin['base_currency_desc']} ({coin['base_currency']})<br>💲{round(coin['market_cap_calc']/1_000_000):,} Million | {', '.join(coin['crypto_common_categories'])}"
+            plotly_title = f"{coin['base_currency_desc']} ({coin['base_currency']})<br>💲{self.moneystring(coin['market_cap_calc'])} | {', '.join(coin['crypto_common_categories'])}"
+        
+        elif ticker in self.etf['name'].tolist() :
+            # ETF
+            t = self.etf.loc[self.etf['name']==ticker].iloc[0]
+            plotly_title = f"{t['description']} ({t['name']}) | 💲{round(t['close'], 2)} <br>AUM:💲{self.moneystring(t['aum'])} | {t['focus.tr']}  | Expense ratio {t['expense_ratio']}"
         else:
+            # stock
             t = self.get_one_stock_info(ticker)
-            plotly_title = f"{t['name']} ({t['ticker']}) | 💲{round(t['price'], 2)} | {t['sector']} | {t['industry']} <br>{t['market_cap_text']} | 👨‍💼 {round(t['n_emp']):,} <br>Sector location: {t['sec_loc']} | Industry location: {t['ind_loc']}"
+            plotly_title = f"{t['name']} ({t['ticker']}) | 💲{round(t['price'], 2)} | {t['sector']} | {t['industry']} <br>💲{t['market_cap_text']} | 👨‍💼 {round(t['n_emp']):,} <br>Sector location: {t['sec_loc']} | Industry location: {t['ind_loc']}"
         return(plotly_title)
 
+
     def get_sec_plot(self, ticker):
+        """
+        Get plotly figure for a ticker showing the sector location of the stock 
+        Parameters: 
+        - ticker: ticker of the stock
+        Return: plotly figure showing the sector location of the stock
+        """
+
+        if ticker in self.etf['name'].tolist():
+            return f"{ticker} is ETF use get_etf_plot"
         row_df = self.stock.loc[self.stock['name']==ticker]
         row_df.rename(columns = {'description': 'Company'}, inplace=True)
         secdf = self.stock.loc[ (self.stock['sector'] ==row_df['sector'].iloc[0] ) ].reset_index(drop=True)
-        if row_df['market_cap_basic'].iloc[0] <100_000_000:
-            market_cap = f"💲{round(row_df['market_cap_basic'].iloc[0]/1_000_000, 2):,} Million"
-        else:
-            market_cap = f"💲{round(row_df['market_cap_basic'].iloc[0]/1_000_000):,} Million"
-
-
         secdf.rename(columns = {'description': 'Company'}, inplace=True)
-
-        #fig = px.bar(secdf, x='name', y='market_cap_basic', title = f"{row_df['Company'].iloc[0]} ({row_df['name'].iloc[0]})<br>{row_df['sector'].iloc[0]} | {row_df['industry'].iloc[0]}", labels={'market_cap_basic':'Market kapitalization'}, text='Company')
-
-        fig = px.bar(secdf, x='name', y='market_cap_basic', title = self.get_plotly_title(ticker), labels={'market_cap_basic':'Market kapitalization'}, text='Company')
-
-        fig.add_annotation( x=row_df['name'].iloc[0], y=row_df['market_cap_basic'].iloc[0], text= f"{market_cap}",  showarrow=True, align="center", bordercolor="#c7c7c7", font=dict(family="Courier New, monospace", size=16, color="#214e34" ), borderwidth=2, borderpad=4, bgcolor="#f4fdff", opacity=0.8, arrowhead=2, arrowsize=1, arrowwidth=1, ax=65,ay=-45)
+        fig = px.bar(secdf, x='name', y='market_cap_basic', title = f"{row_df['Company'].iloc[0]} ({row_df['name'].iloc[0]})<br>{row_df['sector'].iloc[0]} | {row_df['industry'].iloc[0]}", labels={'market_cap_basic':'Market kapitalization'}, text='Company')
+        fig = px.bar(secdf, x='name', y='market_cap_basic', title = self.get_plotly_title(ticker), labels={'market_cap_basic':'Market Capitalization'}, text='Company')
+        fig.add_annotation( x=row_df['name'].iloc[0], y=row_df['market_cap_basic'].iloc[0], text= f"{self.moneystring(row_df['market_cap_basic'].iloc[0])}",  showarrow=True, align="center", bordercolor="#c7c7c7", font=dict(family="Courier New, monospace", size=16, color="#214e34" ), borderwidth=2, borderpad=4, bgcolor="#f4fdff", opacity=0.8, arrowhead=2, arrowsize=1, arrowwidth=1, ax=65,ay=-45)
         fig.update_layout(showlegend=False, plot_bgcolor='white', height=600)
         return (fig)
 
+
     def get_ind_plot(self, ticker):
+        """
+        Get plotly figure for a ticker showing the industry location of the stock
+        Parameters: 
+        - ticker: ticker of the stock
+        Return: plotly figure showing the industry location of the stock
+        """
+
+        if ticker in self.etf['name'].tolist():
+            return f"{ticker} is ETF use get_etf_plot"
         row_df = self.stock.loc[self.stock['name']==ticker]
         inddf = self.stock.loc[ (self.stock['industry'] ==row_df['industry'].iloc[0] ) ].reset_index(drop=True)
         row_df.rename(columns = {'description': 'Company'}, inplace=True)
-
-        if row_df['market_cap_basic'].iloc[0] <100_000_000:
-            market_cap = f"💲{round(row_df['market_cap_basic'].iloc[0]/1_000_000, 2):,} Million"
-        else:
-            market_cap = f"💲{round(row_df['market_cap_basic'].iloc[0]/1_000_000):,} Million"
-
         inddf.rename(columns = {'description': 'Company'}, inplace=True)
-
-        fig = px.bar(inddf, x='name', y='market_cap_basic', title = self.get_plotly_title(ticker), labels={'market_cap_basic':'Market kapitalization'}, text='Company')
+        fig = px.bar(inddf, x='name', y='market_cap_basic', title = self.get_plotly_title(ticker), labels={'market_cap_basic':'Market Capitalization'}, text='Company')
+        fig.add_annotation( x=row_df['name'].iloc[0], y=row_df['market_cap_basic'].iloc[0], text= f"{self.moneystring(row_df['market_cap_basic'].iloc[0])}",  showarrow=True, align="center", bordercolor="#c7c7c7", font=dict(family="Courier New, monospace", size=16, color="#214e34" ), borderwidth=2, borderpad=4, bgcolor="#f4fdff", opacity=0.8, arrowhead=2, arrowsize=1, arrowwidth=1, ax=65,ay=-45)
+        fig.update_layout(showlegend=False, plot_bgcolor='white', height=600)
+        return (fig)
 
 
-        fig.add_annotation( x=row_df['name'].iloc[0], y=row_df['market_cap_basic'].iloc[0], text= f"{market_cap}",  showarrow=True, align="center", bordercolor="#c7c7c7", font=dict(family="Courier New, monospace", size=16, color="#214e34" ), borderwidth=2, borderpad=4, bgcolor="#f4fdff", opacity=0.8, arrowhead=2, arrowsize=1, arrowwidth=1, ax=65,ay=-45)
+    def get_etf_plot(self, ticker):
+        """
+        Get plotly figure for a ETF showing the ETF location with the same focus
+        Parameters:
+        - ticker: ticker of the ETF
+        Return: plotly figure showing the ETF location with the same focus
+        
+        """
+        row_df = self.etf.loc[self.etf['name']==ticker]
+        focdf = self.etf.loc[ (self.etf['focus.tr'] ==row_df['focus.tr'].iloc[0] ) ].reset_index(drop=True)
+        fig = px.bar(focdf, x='name', y='aum', title = self.get_plotly_title(ticker), labels={'aum':'Assets Under Management'}, text='description')
+        fig.add_annotation( x=row_df['name'].iloc[0], y=row_df['aum'].iloc[0], text= f"{self.moneystring(row_df['aum'].iloc[0])}",  showarrow=True, align="center", bordercolor="#c7c7c7", font=dict(family="Courier New, monospace", size=16, color="#214e34" ), borderwidth=2, borderpad=4, bgcolor="#f4fdff", opacity=0.8, arrowhead=2, arrowsize=1, arrowwidth=1, ax=65,ay=-45)
         fig.update_layout(showlegend=False, plot_bgcolor='white', height=600)
         return (fig)
         
 
 
+
 #tw = Tw()
 #print(tw.stock.head(1).T)
 #print(tw.crypto.head(1).T)

{goldhand-15.4.dist-info → goldhand-15.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: goldhand
-Version: 15.4
+Version: 15.7
 Summary: A package working with financial data
 Home-page: https://github.com/misrori/goldhand
 Author: Mihaly
@@ -25,7 +25,6 @@ pip install goldhand
 ```
 
 
-
 # TradingView
 
 
@@ -40,11 +39,15 @@ tw.stock
 
 # data frame of the top 300 crypto currency
 tw.crypto
+
+# data frame of the top 3000 etf
+tw.etf
+
 ```
 
 ```python
 # Get a plot of the stock to see the location in the sector 
-tw.get_sec_plot('AMD')
+tw.get_sec_plot('AMD').show()
 
 ```
 ![Sector plot](https://github.com/misrori/goldhand/blob/main/img/sec_plot.png?raw=true "Sector location of FDS")
@@ -52,7 +55,7 @@ tw.get_sec_plot('AMD')
 
 ```python
 # Get a plot of the stock to see the location in the industry 
-tw.get_sec_plot('AMD')
+tw.get_sec_plot('AMD').show()
 
 ```
 ![Sector plot](https://github.com/misrori/goldhand/blob/main/img/ind_plot.png?raw=true  "Sector location of FDS")

goldhand-15.7.dist-info/RECORD

@@ -0,0 +1,11 @@
+goldhand/__init__.py,sha256=2D68nqSZuv6sqyLJbOXnWIeeFpNgpYc90rHa2Fo70lk,152
+goldhand/backtest.py,sha256=dfrm2Mntp-qUCXsmayExuQgLur5U30QZ6wYJLt7Wq68,7576
+goldhand/helpers.py,sha256=l9yn0kVTiwfUR8sI5nH1QFx6dYikaUQgRA227Ox7hs0,6130
+goldhand/stocks.py,sha256=knYaAD0pkQepPfDMqHSXZvx4oWhVdts57WRaJQYqF18,13792
+goldhand/strategy_goldhand_line.py,sha256=h2yAA4XGTxQ1qaN1EPVwCpKDEDiWVy2DMZ0ssFVXN88,12315
+goldhand/strategy_rsi.py,sha256=yS6YZ1zeKURvy9wELWXX6clcr0AM-ptPgILgM8hXgPA,10485
+goldhand/tw.py,sha256=4W8xmCbDkI4UGRVxgA7aNtyddXOLTprNgUihwSh0-lI,12557
+goldhand-15.7.dist-info/METADATA,sha256=4o42aSMO8TNT5AzuilA7sWAQ0SQFncDpSq6zpNUuiwI,2007
+goldhand-15.7.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+goldhand-15.7.dist-info/top_level.txt,sha256=siEJ2_a_Fx_7hqRI4Ms6SzCelbXrK_1H_eOF8KAaMdA,9
+goldhand-15.7.dist-info/RECORD,,

goldhand-15.4.dist-info/RECORD

@@ -1,11 +0,0 @@
-goldhand/__init__.py,sha256=2D68nqSZuv6sqyLJbOXnWIeeFpNgpYc90rHa2Fo70lk,152
-goldhand/backtest.py,sha256=haK0c7wbUv02DUU5LcrvDSC1i0h1nDX7HHYzD9abhb8,6456
-goldhand/helpers.py,sha256=l9yn0kVTiwfUR8sI5nH1QFx6dYikaUQgRA227Ox7hs0,6130
-goldhand/stocks.py,sha256=rQmcBo6cwu8mXmVSqT9PJhHCHJ9X1laPwhqX5sDHS6E,11886
-goldhand/strategy_goldhand_line.py,sha256=TEb16PvaoX07bjtTRVMYlz2ilJ_YlQ2Q6_o-sAC60QQ,12056
-goldhand/strategy_rsi.py,sha256=JhmefDm-PXmIT2tQNeLFjaDb0SpR1yln33wuDPt1Zp4,9540
-goldhand/tw.py,sha256=Rv0oy9QjX3FC_7Rxiv_oUftQhkvrq65LUgbrhwXhWDE,8460
-goldhand-15.4.dist-info/METADATA,sha256=OAiDn38e4u0l9lorFyMv1yali-oDlvdXL1upFholHRE,1952
-goldhand-15.4.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-goldhand-15.4.dist-info/top_level.txt,sha256=siEJ2_a_Fx_7hqRI4Ms6SzCelbXrK_1H_eOF8KAaMdA,9
-goldhand-15.4.dist-info/RECORD,,