goldhand 20.3__tar.gz

goldhand-20.3/PKG-INFO

@@ -0,0 +1,199 @@
+Metadata-Version: 2.4
+Name: goldhand
+Version: 20.3
+Summary: A package working with financial data
+Home-page: https://github.com/misrori/goldhand
+Author: Mihaly
+Author-email: ormraat.pte@gmail.com
+License: MIT
+Description-Content-Type: text/markdown
+Requires-Dist: pandas
+Requires-Dist: plotly
+Requires-Dist: scipy
+Requires-Dist: numpy
+Requires-Dist: numba
+Requires-Dist: requests
+Requires-Dist: tqdm
+Requires-Dist: yfinance<1.0
+Requires-Dist: ipython
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+
+# [Goldhand](https://github.com/misrori/goldhand)
+The ultimate python package to work with stock and crypto data
+
+```bash
+pip install goldhand
+```
+
+
+# [TradingView]((https://github.com/misrori/goldhand/tw.py))
+
+
+```python
+from goldhand import *
+
+# tradingView data
+tw = Tw()
+
+# data frame of the stocks 
+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').show()
+
+```
+![Sector plot](https://github.com/misrori/goldhand/blob/main/img/sec_plot.png?raw=true "Sector location of FDS")
+
+
+```python
+# Get a plot of the stock to see the location in the industry 
+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 class](https://github.com/misrori/goldhand/stock.py)
+
+The `GoldHand` class is a part of the `goldhand` Python package, which provides functionality for working with stock and crypto data. This class allows users to retrieve detailed information and charts for a specific stock.
+
+
+
+```python
+
+# Get a detailed chart of a stock AMD
+ticker = "AMD"
+t = GoldHand(ticker)
+t.df.tail().T
+```
+![data structure](https://github.com/misrori/goldhand/blob/main/img/df_structure.png?raw=true "data structure")
+
+
+```python
+
+# Get a detailed chart of a stock AMD
+ticker = "TSLA"
+t = GoldHand(ticker)
+t.plotly_last_year(tw.get_plotly_title(ticker)).show()
+
+## Stock Chart
+
+```
+!['Detailed stock chart'](https://github.com/misrori/goldhand/blob/main/img/stock_plot.png?raw=true  "Stock plot")
+
+```python
+
+# Get a detailed chart of a crypto
+ticker = "BTC-USD"
+t = GoldHand(ticker)
+t.plotly_last_year(tw.get_plotly_title(ticker)).show()
+
+
+```
+!['Detailed crypto chart'](https://github.com/misrori/goldhand/blob/main/img/crypto_plot.png?raw=true  "crypto plot")
+
+
+## [GoldHand Line indicator](https://gist.github.com/misrori/ae77642c31fb1a973c7627cc077a1df2) 
+
+
+```python
+ticker = "TSLA"
+t = GoldHand(ticker)
+t.plot_goldhand_line(tw.get_plotly_title(ticker)).show()
+
+```
+!['Detailed crypto chart'](https://github.com/misrori/goldhand/blob/main/img/goldhand_line_plot.png?raw=true  "crypto plot")
+
+
+
+# [Backtest](https://github.com/misrori/goldhand/backtest.py)
+
+The Backtest class is a powerful tool for evaluating the performance of trading strategies using historical data. It allows you to simulate trades and calculate various performance metrics to assess the profitability and risk of your strategy.
+
+It takes a data and a function and display the trades. 
+
+
+
+```python
+ticker= 'TSLA'
+data = GoldHand(ticker).df
+backtest = Backtest( data, rsi_strategy, plot_title=tw.get_plotly_title(ticker),  buy_threshold=30, sell_threshold=70)
+backtest.summarize_strategy()
+
+```
+`summarize_strategy`  will  show the trades summary, a plot with trades and the trades in DataFrame.
+
+
+!['Summary of trades'](https://github.com/misrori/goldhand/blob/main/img/tradesdf.png?raw=true  "summary of trades")
+
+!['Trades plot'](https://github.com/misrori/goldhand/blob/main/img/backtest_plot.png?raw=true  "trades plot")
+
+!['Trades'](https://github.com/misrori/goldhand/blob/main/img/trades_summary.png?raw=true  "trades df")
+
+
+# Strategys
+
+## [RSI Strategy](https://github.com/misrori/goldhand/strategy_rsi.py)
+
+```python
+    """
+    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
+    """
+    backtest = Backtest( data, rsi_strategy, plot_title=tw.get_plotly_title(ticker),  buy_threshold=30, sell_threshold=70)
+
+```
+
+
+```python
+ticker = 'TSLA'
+p = show_indicator_rsi_strategy(ticker = ticker, buy_threshold=30, sell_threshold=70, plot_title=tw.get_plotly_title(ticker), add_strategy_summary=True)
+```
+!['RSI strategy plot'](https://github.com/misrori/goldhand/blob/main/img/rsi_strategy_plot.png?raw=true  "RSI Strategy plot")
+
+## [GoldHand Line indicator](https://github.com/misrori/goldhand/strategy_goldhand_line.py) 
+
+```python
+    """
+    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'.
+    
+    """
+    backtest = Backtest( data, goldhand_line_strategy,)
+
+```
+
+```python
+ticker = 'BTC-USD'
+show_indicator_goldhand_line_strategy(ticker = ticker, plot_title=tw.get_plotly_title(ticker), buy_at='gold', sell_at='blue',  add_strategy_summary=True)
+```
+!['GoldHand Line strategy plot'](https://github.com/misrori/goldhand/blob/main/img/goldhand_line_strategy_plot.png?raw=true  "GoldHand Line Strategy plot")
+
+
+

goldhand-20.3/README.md

@@ -0,0 +1,172 @@
+
+# [Goldhand](https://github.com/misrori/goldhand)
+The ultimate python package to work with stock and crypto data
+
+```bash
+pip install goldhand
+```
+
+
+# [TradingView]((https://github.com/misrori/goldhand/tw.py))
+
+
+```python
+from goldhand import *
+
+# tradingView data
+tw = Tw()
+
+# data frame of the stocks 
+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').show()
+
+```
+![Sector plot](https://github.com/misrori/goldhand/blob/main/img/sec_plot.png?raw=true "Sector location of FDS")
+
+
+```python
+# Get a plot of the stock to see the location in the industry 
+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 class](https://github.com/misrori/goldhand/stock.py)
+
+The `GoldHand` class is a part of the `goldhand` Python package, which provides functionality for working with stock and crypto data. This class allows users to retrieve detailed information and charts for a specific stock.
+
+
+
+```python
+
+# Get a detailed chart of a stock AMD
+ticker = "AMD"
+t = GoldHand(ticker)
+t.df.tail().T
+```
+![data structure](https://github.com/misrori/goldhand/blob/main/img/df_structure.png?raw=true "data structure")
+
+
+```python
+
+# Get a detailed chart of a stock AMD
+ticker = "TSLA"
+t = GoldHand(ticker)
+t.plotly_last_year(tw.get_plotly_title(ticker)).show()
+
+## Stock Chart
+
+```
+!['Detailed stock chart'](https://github.com/misrori/goldhand/blob/main/img/stock_plot.png?raw=true  "Stock plot")
+
+```python
+
+# Get a detailed chart of a crypto
+ticker = "BTC-USD"
+t = GoldHand(ticker)
+t.plotly_last_year(tw.get_plotly_title(ticker)).show()
+
+
+```
+!['Detailed crypto chart'](https://github.com/misrori/goldhand/blob/main/img/crypto_plot.png?raw=true  "crypto plot")
+
+
+## [GoldHand Line indicator](https://gist.github.com/misrori/ae77642c31fb1a973c7627cc077a1df2) 
+
+
+```python
+ticker = "TSLA"
+t = GoldHand(ticker)
+t.plot_goldhand_line(tw.get_plotly_title(ticker)).show()
+
+```
+!['Detailed crypto chart'](https://github.com/misrori/goldhand/blob/main/img/goldhand_line_plot.png?raw=true  "crypto plot")
+
+
+
+# [Backtest](https://github.com/misrori/goldhand/backtest.py)
+
+The Backtest class is a powerful tool for evaluating the performance of trading strategies using historical data. It allows you to simulate trades and calculate various performance metrics to assess the profitability and risk of your strategy.
+
+It takes a data and a function and display the trades. 
+
+
+
+```python
+ticker= 'TSLA'
+data = GoldHand(ticker).df
+backtest = Backtest( data, rsi_strategy, plot_title=tw.get_plotly_title(ticker),  buy_threshold=30, sell_threshold=70)
+backtest.summarize_strategy()
+
+```
+`summarize_strategy`  will  show the trades summary, a plot with trades and the trades in DataFrame.
+
+
+!['Summary of trades'](https://github.com/misrori/goldhand/blob/main/img/tradesdf.png?raw=true  "summary of trades")
+
+!['Trades plot'](https://github.com/misrori/goldhand/blob/main/img/backtest_plot.png?raw=true  "trades plot")
+
+!['Trades'](https://github.com/misrori/goldhand/blob/main/img/trades_summary.png?raw=true  "trades df")
+
+
+# Strategys
+
+## [RSI Strategy](https://github.com/misrori/goldhand/strategy_rsi.py)
+
+```python
+    """
+    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
+    """
+    backtest = Backtest( data, rsi_strategy, plot_title=tw.get_plotly_title(ticker),  buy_threshold=30, sell_threshold=70)
+
+```
+
+
+```python
+ticker = 'TSLA'
+p = show_indicator_rsi_strategy(ticker = ticker, buy_threshold=30, sell_threshold=70, plot_title=tw.get_plotly_title(ticker), add_strategy_summary=True)
+```
+!['RSI strategy plot'](https://github.com/misrori/goldhand/blob/main/img/rsi_strategy_plot.png?raw=true  "RSI Strategy plot")
+
+## [GoldHand Line indicator](https://github.com/misrori/goldhand/strategy_goldhand_line.py) 
+
+```python
+    """
+    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'.
+    
+    """
+    backtest = Backtest( data, goldhand_line_strategy,)
+
+```
+
+```python
+ticker = 'BTC-USD'
+show_indicator_goldhand_line_strategy(ticker = ticker, plot_title=tw.get_plotly_title(ticker), buy_at='gold', sell_at='blue',  add_strategy_summary=True)
+```
+!['GoldHand Line strategy plot'](https://github.com/misrori/goldhand/blob/main/img/goldhand_line_strategy_plot.png?raw=true  "GoldHand Line Strategy plot")
+
+
+

goldhand-20.3/goldhand/__init__.py

@@ -0,0 +1,9 @@
+from goldhand.stocks import GoldHand
+from goldhand.backtest import Backtest
+from goldhand.data import Data
+from goldhand.indicators import Indicators
+from goldhand.plotting import Plotting
+from goldhand.tw import Tw
+from goldhand.strategies import goldhand_line_strategy, show_indicator_goldhand_line_strategy
+from goldhand.strategies import rsi_strategy, show_indicator_rsi_strategy
+from goldhand.strategies import adaptive_trend_strategy, show_indicator_adaptive_trend_strategy

goldhand-20.3/goldhand/backtest.py

@@ -0,0 +1,168 @@
+from IPython.display import display
+import pandas as pd
+import numpy as np
+from goldhand.plotting import Plotting
+
+class Backtest:
+    """
+    Backtest class for running trading strategies.
+    """
+    
+    def __init__(self, data, strategy_func, plot_title='Backtest', **kwargs):
+        """
+        Initialize backtest.
+        
+        Parameters:
+        - data: DataFrame with OHLCV data
+        - strategy_func: Function that takes data and returns trades DataFrame
+        - plot_title: Title for plots
+        - **kwargs: Additional parameters to pass to strategy function
+        """
+        self.data = data.copy()
+        self.strategy_func = strategy_func
+        self.plot_title = plot_title
+        self.additional_params = kwargs
+        
+        # Run strategy
+        self.trades = self.strategy_func(self.data, **kwargs)
+        
+        # Ensure trades is a DataFrame
+        if not isinstance(self.trades, pd.DataFrame):
+            self.trades = pd.DataFrame()
+            
+        # Reorder columns for better readability
+        if not self.trades.empty:
+            first = ['ticker', 'buy_price', 'buy_date', 'trade_id', 'status', 'sell_price', 'sell_date', 'result', 'days_in_trade']
+            all_col = list(self.trades.columns)
+            first = [x for x in first if x in all_col]
+            first.extend([x for x in all_col if x not in first])
+            self.trades = self.trades[first]
+            
+        self.calculate_summary()
+
+    def calculate_summary(self):
+        """
+        Calculate comprehensive performance metrics.
+        """
+        if self.trades.empty:
+            self.trades_summary = {'number_of_trades': 0}
+            self.trade_summary_plot_text = "No trades executed."
+            return
+
+        # Explicit type conversion to numeric to avoid errors
+        results = pd.to_numeric(self.trades['result'], errors='coerce').fillna(1.0)
+        days = pd.to_numeric(self.trades['days_in_trade'], errors='coerce').fillna(0)
+        
+        n_trades = len(self.trades)
+        win_trades = results[results > 1]
+        loss_trades = results[results < 1]
+        
+        # Calculate profit percentages
+        profit_pcts = (results - 1) * 100
+        win_profit_pcts = profit_pcts[results > 1]
+        loss_profit_pcts = profit_pcts[results < 1]
+        
+        # Basic metrics
+        win_ratio = (len(win_trades) / n_trades) * 100 if n_trades > 0 else 0
+        avg_res = profit_pcts.mean()
+        median_res = profit_pcts.median()
+        cum_res = results.prod()
+        
+        # Detailed profit/loss metrics
+        profitable_trades_mean = win_profit_pcts.mean() if len(win_profit_pcts) > 0 else 0
+        profitable_trades_median = win_profit_pcts.median() if len(win_profit_pcts) > 0 else 0
+        looser_trades_mean = loss_profit_pcts.mean() if len(loss_profit_pcts) > 0 else 0
+        looser_trades_median = loss_profit_pcts.median() if len(loss_profit_pcts) > 0 else 0
+        
+        # Trade results lists
+        trade_results_str = " # ".join([f"{x:.2f}" for x in profit_pcts.values[:10]])  # First 10
+        if len(profit_pcts) > 10:
+            trade_results_str += " # ..."
+            
+        profitable_results_str = " # ".join([f"{x:.2f}" for x in win_profit_pcts.values[:10]])
+        if len(win_profit_pcts) > 10:
+            profitable_results_str += " # ..."
+            
+        looser_results_str = " # ".join([f"{x:.2f}" for x in loss_profit_pcts.values[:10]])
+        if len(loss_profit_pcts) > 10:
+            looser_results_str += " # ..."
+        
+        # Date and price info
+        first_trade_date = self.trades['buy_date'].iloc[0] if 'buy_date' in self.trades.columns else None
+        last_trade_date = self.trades['sell_date'].iloc[-1] if 'sell_date' in self.trades.columns else None
+        first_data_date = self.data['date'].iloc[0]
+        last_data_date = self.data['date'].iloc[-1]
+        first_open_price = self.data['open'].iloc[0]
+        last_close_price = self.data['close'].iloc[-1]
+        
+        # Hold result
+        hold_result = last_close_price / first_open_price
+        
+        # Buy/Sell colors (from original strategy if available)
+        buy_color = self.additional_params.get('buy_at', 'gold')
+        sell_color = self.additional_params.get('sell_at', 'grey')
+        
+        self.trades_summary = {
+            'ticker': self.data['ticker'].iloc[0] if 'ticker' in self.data.columns else 'Unknown',
+            'number_of_trades': n_trades,
+            'win_ratio(%)': round(win_ratio, 2),
+            'average_res(%)': round(avg_res, 2),
+            'average_trade_len(days)': round(days.mean(), 1),
+            'median_res(%)': round(median_res, 2),
+            'cumulative_result': round(cum_res, 6),
+            'trade_results': trade_results_str,
+            'profitable_trade_results': profitable_results_str,
+            'profitable_trades_mean': round(profitable_trades_mean, 2),
+            'profitable_trades_median': round(profitable_trades_median, 2),
+            'looser_trade_results': looser_results_str,
+            'looser_trades_mean': round(looser_trades_mean, 2),
+            'looser_trades_median': round(looser_trades_median, 2),
+            'median_trade_len(days)': round(days.median(), 1),
+            'number_of_win_trades': len(win_trades),
+            'number_of_lost_trades': len(loss_trades),
+            'max_gain(%)': round((results.max() - 1) * 100, 2),
+            'max_lost(%)': round((results.min() - 1) * 100, 2),
+            'first_trade_buy': str(first_trade_date) if first_trade_date else 'N/A',
+            'first_data_date': str(first_data_date),
+            'first_open_price': round(first_open_price, 6),
+            'last_data_date': str(last_data_date),
+            'last_close_price': round(last_close_price, 6),
+            'hold_result': f"{round(hold_result, 2)} x",
+            'buy_at': buy_color,
+            'sell_at': sell_color
+        }
+        
+        # Add additional params to summary for context
+        self.trades_summary.update(self.additional_params)
+        
+        # Format text for plot
+        self.trade_summary_plot_text = (
+            f"Trades: {self.trades_summary['number_of_trades']}<br>"
+            f"Win ratio: {self.trades_summary['win_ratio(%)']}%<br>"
+            f"Avg Result: {self.trades_summary['average_res(%)']}%<br>"
+            f"Cum Result: {self.trades_summary['cumulative_result']}<br>"
+            f"Hold Result: {self.trades_summary['hold_result']}"
+        )
+
+    def show_trades(self):
+        """
+        Return the plotly figure with trades.
+        """
+        if self.trades.empty:
+            print("No trades to show.")
+            return Plotting._create_base_ohlc(self.data)
+            
+        return Plotting.plot_strategy_trades(
+            self.data, 
+            self.trades, 
+            title=self.plot_title,
+            summary_text=self.trade_summary_plot_text
+        )
+
+    def summarize_strategy(self):
+        """
+        Display summary table and plot.
+        """
+        display(pd.DataFrame(self.trades_summary, index=['Strategy summary']).T)
+        self.show_trades().show()
+        display(self.trades)

goldhand-20.3/goldhand/data.py

@@ -0,0 +1,68 @@
+import yfinance as yf
+import pandas as pd
+from datetime import datetime, timedelta
+
+class Data:
+    """
+    Class to handle data downloading from Yahoo Finance.
+    """
+    
+    @staticmethod
+    def download(ticker: str, period: str = 'max', interval: str = '1d', auto_adjust: bool = True) -> pd.DataFrame:
+        """
+        Download historical data for a single ticker.
+        
+        Parameters:
+        - ticker: str, symbol (e.g., 'AAPL', 'BTC-USD')
+        - period: str, data period to download (e.g. '1y', '2y', 'max')
+        - interval: str, data interval (e.g. '1d', '1h')
+        
+        Returns:
+        - pd.DataFrame with lowercase columns ['date', 'open', 'high', 'low', 'close', 'volume', 'ticker']
+        """
+        try:
+            # Using yfinance to download data
+            # auto_adjust=True fixes the Close price for splits and dividends
+            df = yf.download(ticker, period=period, interval=interval, auto_adjust=auto_adjust, progress=False, multi_level_index=False)
+            
+            if df.empty:
+                print(f"Warning: No data found for ticker {ticker}")
+                return pd.DataFrame()
+
+            # Clean up DataFrame
+            df.reset_index(inplace=True)
+            df.columns = df.columns.str.lower()
+            
+            # Rename 'Date'/'Datetime' to 'date' consistently
+            if 'date' not in df.columns:
+                if 'datetime' in df.columns:
+                    df.rename(columns={'datetime': 'date'}, inplace=True)
+            
+            # Ensure 'date' column is datetime.date objects for compatibility with existing logic
+            if 'date' in df.columns:
+                df['date'] = pd.to_datetime(df['date']).dt.date
+
+            # Add ticker column
+            df['ticker'] = ticker
+            
+            # Select relevant columns
+            cols = ['date', 'open', 'high', 'low', 'close', 'volume', 'ticker']
+            df = df[[c for c in cols if c in df.columns]]
+            
+            return df
+            
+        except Exception as e:
+            print(f"Error downloading data for {ticker}: {e}")
+            return pd.DataFrame()
+
+    @staticmethod
+    def get_ticker_info(ticker: str) -> dict:
+        """
+        Get fundamental info about the ticker.
+        """
+        try:
+            t = yf.Ticker(ticker)
+            return t.info
+        except Exception as e:
+            print(f"Error getting info for {ticker}: {e}")
+            return {}