listings

Author: chrisrobc

listings/chapter_1/1_1_type_hinting_examples.py

@@ -0,0 +1,51 @@
+from typing import List, Dict, Tuple, Any
+import numpy as np
+import datetime
+
+# A list of floating point numbers
+v: List[float] = [i * 1.23 for i in range(10)]
+
+# A list of mixed type values
+v: List[Any] = ['apple', 123, 'banana', None]
+
+# A dictionary of floats indexed by dates
+v: Dict[datetime.date, float] = {
+ datetime.date.today(): 123.456,
+ datetime.date(2000, 1, 1): 234.567,
+}
+
+# A dictionary of lists of strings indexed by tuples of integers
+v: Dict[Tuple[int, int], List[str]] = {
+ (2, 3): [
+ 'apple', 
+ 'banana',
+ ],
+ (4, 7): [
+ 'orange',
+ 'pineapple',
+ ]
+}
+
+# An incorrect type hint
+# Your compiler or IDE might complain about this
+v: List[str] = [1, 2, 3]
+
+# A possibly incorrect type hint
+# There is no concensus on whether or not this is correct
+v: List[float] = [1, None, 3, None, 5]
+
+# This is non-descript but correct
+v: List = [(1,2,'a'), (4,5,'b')]
+
+# This is more descriptive
+v: List[Tuple[int, int, str]] = [(1,2,'a'), (4,5,'b')]
+
+# Custom types are supported
+from typing import NewType
+StockTicker = NewType('StockTicker', np.float64)
+ticker: StockTicker = 'AAPL'
+
+# Functions can define input and return types
+def convert_to_string(value: Any) -> str:
+ return str(value)
+ 

listings/chapter_1/1_2_pandas_data_types.py

@@ -0,0 +1,41 @@
+import pandas as pd
+import datetime
+
+data = {
+ 'SPY': {
+ datetime.date(2000, 1, 4): 100,
+ datetime.date(2000, 1, 5): 101,
+ },
+ 'AAPL': {
+ datetime.date(2000, 1, 4): 300,
+ datetime.date(2000, 1, 5): 303,
+ },
+}
+df: pd.DataFrame = pd.DataFrame(data=data)
+print(df)
+# Returns ...
+# SPY AAPL
+# 2000-01-04 100 300
+# 2000-01-05 101 303
+
+# Index by column
+aapl_series: pd.Series = df['AAPL']
+print(aapl_series)
+# Returns ... 
+# 2000-01-04 300
+# 2000-01-05 303
+# Name: AAPL, dtype: int64
+
+# Index by row
+start_of_year_row: pd.Series = df.loc[datetime.date(2000, 1, 4)]
+print(start_of_year_row)
+# Returns ... 
+# SPY 100
+# AAPL 300
+# Name: 2000-01-04, dtype: int64
+
+# Index by both
+start_of_year_price: pd.Series = df['AAPL'][datetime.date(2000, 1, 4)]
+print(start_of_year_price)
+# Returns ... 
+# 300

listings/chapter_1/1_3_pandas_data_types_part_2.py

@@ -0,0 +1,23 @@
+import pandas as pd
+import datetime
+
+data = {
+ 'SPY': {
+ datetime.date(2000, 1, 4): 100,
+ datetime.date(2000, 1, 5): 101,
+ },
+ 'AAPL': {
+ datetime.date(2000, 1, 4): 300,
+ datetime.date(2000, 1, 5): 303,
+ },
+}
+
+### Begin listing
+
+# Create a series
+series = pd.Series(data=data['SPY'])
+print(series)
+# Returns ...
+# 2000-01-04 100
+# 2000-01-05 101
+# dtype: int64

listings/chapter_1/1_4_pandas_indexes.py

@@ -0,0 +1,18 @@
+import pandas as pd
+import datetime
+
+### Begin listing
+
+dates = [datetime.date(2000, 1, i) for i in range(1, 11)]
+values = [i**2 for i in range(1, 11)]
+series = pd.Series(data=values, index=dates)
+
+# O(n) time complexity search through a list
+print(datetime.date(2000, 1, 5) in dates)
+# Returns ...
+# True
+
+# O(1) time complexity search through an index
+print(datetime.date(2000, 1, 5) in series.index)
+# Returns ...
+# True

listings/chapter_2/2_10_maximum_drawdown.py

@@ -0,0 +1,23 @@
+from typing import Dict, Any, Callable
+
+DRAWDOWN_EVALUATORS: Dict[str, Callable] = {
+ 'dollar': lambda price, peak: peak - price,
+ 'percent': lambda price, peak: -((price / peak) - 1),
+ 'log': lambda price, peak: np.log(peak) - np.log(price),
+}
+
+def calculate_drawdown_series(series: pd.Series, method: str='log') -> pd.Series:
+ """
+ Returns the drawdown series
+ """
+ assert method in DRAWDOWN_EVALUATORS, \
+ f'Method "{method}" must by one of {list(DRAWDOWN_EVALUATORS.keys())}'
+
+ evaluator = DRAWDOWN_EVALUATORS[method]
+ return evaluator(series, series.cummax())
+
+def calculate_max_drawdown(series: pd.Series, method: str='log') -> float:
+ """
+ Simply returns the max drawdown as a float
+ """
+ return calculate_drawdown_series(series, method).max()

listings/chapter_2/2_11_maximum_drawdown_with_metadata.py

@@ -0,0 +1,50 @@
+def calculate_max_drawdown_with_metadata(series: pd.Series, 
+ method: str='log') -> Dict[str, Any]:
+ """
+ Calculates max_drawdown and stores metadata about when and where. Returns 
+ a dictionary of the form 
+ {
+ 'max_drawdown': float,
+ 'peak_date': pd.Timestamp,
+ 'peak_price': float,
+ 'trough_date': pd.Timestamp,
+ 'trough_price': float,
+ }
+ """
+
+ assert method in DRAWDOWN_EVALUATORS, \
+ f'Method "{method}" must by one of {list(DRAWDOWN_EVALUATORS.keys())}'
+
+ evaluator = DRAWDOWN_EVALUATORS[method]
+
+ max_drawdown = 0
+ local_peak_date = peak_date = trough_date = series.index[0]
+ local_peak_price = peak_price = trough_price = series.iloc[0]
+
+ for date, price in series.iteritems():
+
+ # Keep track of the rolling max
+ if price > local_peak_price:
+ local_peak_date = date
+ local_peak_price = price
+
+ # Compute the drawdown
+ drawdown = evaluator(price, local_peak_price)
+
+ # Store new max drawdown values
+ if drawdown > max_drawdown:
+ max_drawdown = drawdown
+
+ peak_date = local_peak_date
+ peak_price = local_peak_price
+
+ trough_date = date
+ trough_price = price
+
+ return {
+ 'max_drawdown': max_drawdown,
+ 'peak_date': peak_date,
+ 'peak_price': peak_price,
+ 'trough_date': trough_date,
+ 'trough_price': trough_price
+ }

listings/chapter_2/2_12_log_max_drawdown_ratio.py

@@ -0,0 +1,4 @@
+def calculate_log_max_drawdown_ratio(series: pd.Series) -> float:
+ log_drawdown = calculate_max_drawdown(series, method='log')
+ log_return = np.log(series.iloc[-1]) - np.log(series.iloc[0])
+ return log_return - log_drawdown

listings/chapter_2/2_13_calmar_ratio.py

@@ -0,0 +1,15 @@
+def calculate_calmar_ratio(series: pd.Series, years_past: int=3) -> float:
+ """
+ Return the percent max drawdown ratio over the past three years using
+ CAGR as the numerator, otherwise known as the Calmar Ratio
+ """
+
+ # Filter series on past three years
+ last_date = series.index[-1]
+ three_years_ago = last_date - pd.Timedelta(days=years_past*365.25)
+ series = series[series.index > three_years_ago]
+
+ # Compute annualized percent max drawdown ratio
+ percent_drawdown = calculate_max_drawdown(series, method='percent')
+ cagr = calculate_cagr(series)
+ return cagr / percent_drawdown

listings/chapter_2/2_14_pure_profit_score.py

@@ -0,0 +1,18 @@
+from sklearn.linear_model import LinearRegression
+
+def calculate_pure_profit_score(price_series: pd.Series) -> float:
+ """
+ Calculates the pure profit score
+ """
+ cagr = calculate_cagr(price_series)
+
+ # Build a single column for a predictor, t
+ t: np.ndarray = np.arange(0, price_series.shape[0]).reshape(-1, 1)
+
+ # Fit the regression
+ regression = LinearRegression().fit(t, price_series)
+
+ # Get the r-squared value
+ r_squared = regression.score(t, price_series)
+
+ return cagr * r_squared

listings/chapter_2/2_15_jensens_alpha.py

@@ -0,0 +1,18 @@
+def calculate_jensens_alpha(return_series: pd.Series, 
+ benchmark_return_series: pd.Series) -> float: 
+ """
+ Calculates jensens alpha. Prefers input series have the same index. Handles
+ NAs.
+ """
+
+ # Join series along date index and purge NAs
+ df = pd.concat([return_series, benchmark_return_series], sort=True, axis=1)
+ df = df.dropna()
+
+ # Get the appropriate data structure for scikit learn
+ clean_returns: pd.Series = df[return_series.name]
+ clean_benchmarks = pd.DataFrame(df[benchmark_return_series.name])
+
+ # Fit a linear regression and return the alpha
+ regression = LinearRegression().fit(clean_benchmarks, y=clean_returns)
+ return regression.intercept_