sdevpy 0.1.2__tar.gz → 0.1.4__tar.gz

{sdevpy-0.1.2 → sdevpy-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sdevpy
-Version: 0.1.2
+Version: 0.1.4
 Summary: Python package for Machine Learning in Finance
 Author-email: Sebastien Gurrieri <sebgur@gmail.com>
 Project-URL: Git page, https://github.com/sebgur/SDev.Python

{sdevpy-0.1.2 → sdevpy-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sdevpy"
-version = "0.1.2"
+version = "0.1.4"
 authors = [
   { name="Sebastien Gurrieri", email="sebgur@gmail.com" },
 ]
@@ -17,7 +17,8 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-	"pandas","pyperclip","py_vollib"
+	"pandas","pyperclip","py_vollib","numpy","tensorflow",
+  "scikit-learn"
 ]
 
 [project.urls]

sdevpy-0.1.4/src/sdevpy/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.1.4'

{sdevpy-0.1.2 → sdevpy-0.1.4}/src/sdevpy/analytics/fbsabr.py

@@ -109,15 +109,15 @@ def calculate_fbsabr_alpha(ln_vol, fwd, beta):
     return ln_vol * abs_f ** (1.0 - beta)
 
 if __name__ == "__main__":
-    EXPIRIES = [0.05, 0.10, 0.25, 0.5]
+    EXPIRIES = [3.0, 8.0, 13, 19, 22, 31, 34]
     NSTRIKES = 50
-    FWD = -0.005
-    SHIFT = 0.03
+    FWD = 0.016132
+    SHIFT = 0.00
     SFWD = FWD + SHIFT
     IS_CALL = False
     ARE_CALLS = [IS_CALL] * NSTRIKES
     ARE_CALLS = [ARE_CALLS] * len(EXPIRIES)
-    LNVOL = 0.25
+    LNVOL = 0.48
     # Spread method
     # SPREADS = np.linspace(-200, 200, NSTRIKES)
     # SPREADS = np.asarray([SPREADS] * len(EXPIRIES))
@@ -134,11 +134,11 @@ if __name__ == "__main__":
     STRIKES = SSTRIKES - SHIFT
     XAXIS = STRIKES
 
-    PARAMETERS = {'LnVol': LNVOL, 'Beta': 0.1, 'Nu': 0.50, 'Rho': -0.25}
+    PARAMETERS = {'LnVol': LNVOL, 'Beta': 0.5, 'Nu': 0.66, 'Rho': 0.48}
     NUM_MC = 100 * 1000
     POINTS_PER_YEAR = 25
-    # SCHEME = 'Andersen'
-    SCHEME = 'Euler'
+    SCHEME = 'Andersen'
+    # SCHEME = 'Euler'
 
     # Calculate MC prices
     mc_timer = timer.Stopwatch("MC")

{sdevpy-0.1.2 → sdevpy-0.1.4}/src/sdevpy/analytics/mcheston.py

@@ -28,6 +28,7 @@ def price(expiries, strikes, are_calls, fwd, parameters, num_mc=10000, points_pe
     time_grid = time_grid_builder.complete_grid()
     num_factors = 2
 
+
     # Find payoff times
     is_payoff = np.in1d(time_grid, expiries)
 

sdevpy-0.1.4/src/sdevpy/machinelearning/datasets.py

@@ -0,0 +1,78 @@
+""" Dataset preparation for training """
+import os
+import numpy as np
+import pandas as pd
+from sdevpy.tools import filemanager
+
+
+def prepare_sets(inputs, outputs, train_percent):
+    """ Split input and output datasets into training and test datasets split
+        according to specified percentage to put in the training set """
+    data_size = inputs.shape[0]
+    if outputs.shape[0] != data_size:
+        raise RuntimeError("Incompatible sizes between inputs and outputs")
+
+    train_size = int(data_size * train_percent)
+
+    train_inputs = inputs[0:train_size]
+    train_outputs = outputs[0:train_size]
+    test_inputs = inputs[train_size:data_size]
+    test_outputs = outputs[train_size:data_size]
+
+    return train_inputs, train_outputs, test_inputs, test_outputs
+
+def retrieve_data(folder, num_samples, shuffle=True, sep='\t', export_file=""):
+    """ Use all files in folder to create a dataset, shuffle its data,
+        extract num_samples from it and return dataframe """
+
+    # Set extension
+    if sep == '\t':
+        extension = ".tsv"
+    elif sep == ',':
+        extension = ".csv"
+    else:
+        raise RuntimeError("Unknown text file separation")
+
+    # Merge content of folder in single dataframe
+    files = filemanager.list_files(folder, [extension])
+    df = pd.DataFrame()
+    for f in files:
+        new_df = pd.read_csv(os.path.join(folder, f), sep=sep)
+        df = pd.concat([df, new_df])
+
+    if shuffle:
+        df = df.sample(frac=1)
+
+    # Clip num_samples
+    df = clip_dataframe(df, num_samples)
+
+    # If export_file is not empty, export to file
+    if export_file != "":
+        df.to_csv(export_file, sep=sep, index=False)
+
+    return df
+
+def clip_dataframe(df, size):
+    """ Clip dataframe beyond specified size"""
+    df_size = len(df.index)
+    if df_size <= size:
+        return df
+    else:
+        return df.iloc[range(0, size)]
+
+
+if __name__ == "__main__":
+    INPUTS = np.asarray([[1, 1], [2, 2], [3, 3], [4, 4], [5, 5]])
+    OUTPUTS = np.asarray([[1], [2], [3], [4], [5]])
+    train_x, train_y, test_x, test_y = prepare_sets(INPUTS, OUTPUTS, 0.80)
+    print(train_x)
+    print(train_y)
+    print(test_x)
+    print(test_y)
+
+    # Test merging
+    FOLDER = r"C:\temp\sdevpy\stovol\samples\test"
+    NUM_SAMPLES = 4
+    DATA_FILE = r"C:\temp\sdevpy\stovol\samples\test.tsv"
+    DATA_DF = retrieve_data(FOLDER, NUM_SAMPLES, export_file=DATA_FILE, shuffle=True)
+    print(DATA_DF)

{sdevpy-0.1.2 → sdevpy-0.1.4}/src/sdevpy/maths/metrics.py

@@ -8,6 +8,15 @@ def rmse(set1, set2):
     """ Root Mean Squared Error """
     return np.sqrt(mean_squared_error(set1, set2))
 
+def bps_rmse(y_true, y_ref):
+    """ RMSE in bps """
+    return 10000.0 * rmse(y_true, y_ref)
+
+# Tensorflow versions
 def tf_rmse(y_true, y_pred):
     """ Root Mean Squared Error in tensorflow """
     return tf.sqrt(tf.math.reduce_mean(tf.square(y_true - y_pred)))
+
+def tf_bps_rmse(y_true, y_ref):
+    """ RMSE in bps in tensorflow """
+    return 10000.0 * tf_rmse(y_true, y_ref)

{sdevpy-0.1.2 → sdevpy-0.1.4}/src/sdevpy/projects/stovol/stovolgen.py

@@ -4,21 +4,21 @@
 import os
 from sdevpy.volsurfacegen import stovolfactory
 from sdevpy import settings
-from sdevpy.tools.filemanager import check_directory
+from sdevpy.tools import filemanager
 from sdevpy.tools.timer import Stopwatch
 
 
 # ################ Runtime configuration ##########################################################
 # MODEL_TYPE = "SABR"
-# MODEL_TYPE = "ShiftedSABR"
-# MODEL_TYPE = "McShiftedSABR"
-MODEL_TYPE = "FbSABR"
-# MODEL_TYPE = "McShiftedZABR"
-# MODEL_TYPE = "McShiftedHeston"
-NUM_SAMPLES = 400 * 1000
+# MODEL_TYPE = "McSABR"
+# MODEL_TYPE = "FbSABR"
+# MODEL_TYPE = "McZABR"
+MODEL_TYPE = "McHeston"
+SHIFT = 0.03
+NUM_SAMPLES = 1 * 1000
 # The 4 parameters below are only relevant for models whose reference is calculated by MC
 NUM_EXPIRIES = 10
-SURFACE_SIZE = 50
+NUM_STRIKES = 5
 NUM_MC = 100 * 1000 # 100 * 1000
 POINTS_PER_YEAR = 25 # 25
 SEED = 42# [123456789, 6789, 9191, 888, 4321, 100, 4444, 72, 1234, 42]
@@ -28,21 +28,36 @@ project_folder = os.path.join(settings.WORKFOLDER, "stovol")
 print("> Project folder: " + project_folder)
 data_folder = os.path.join(project_folder, "samples")
 print("> Data folder: " + data_folder)
-check_directory(data_folder)
+filemanager.check_directory(data_folder)
 print("> Chosen model: " + MODEL_TYPE)
 data_file = os.path.join(data_folder, MODEL_TYPE + "_samples.tsv")
 
-# ################ Select model ###############################################################
-generator = stovolfactory.set_generator(MODEL_TYPE, NUM_EXPIRIES, SURFACE_SIZE, NUM_MC,
+# ################ Select model ###################################################################
+generator = stovolfactory.set_generator(MODEL_TYPE, SHIFT, NUM_EXPIRIES, NUM_STRIKES, NUM_MC,
                                         POINTS_PER_YEAR, SEED)
 
+# ################ Select training ranges #########################################################
+# # SABR
+# RANGES = {'Ttm': [1.0 / 12.0, 35.0], 'K': [0.01, 0.99], 'F': [-0.009, 0.041], 'LnVol': [0.05, 0.5],
+#           'Beta': [0.1, 0.9], 'Nu': [0.1, 1.0], 'Rho': [-0.6, 0.6]}
+# # ZABR
+# RANGES = {'Ttm': [1.0 / 12.0, 35.0], 'K': [0.01, 0.99], 'F': [-0.009, 0.041], 'LnVol': [0.05, 0.25],
+#           'Beta': [0.49, 0.51], 'Nu': [0.20, 0.80], 'Rho': [-0.4, 0.4],
+#           'Gamma': [0.10, 0.9]}
+# Heston
+RANGES = {'Ttm': [1.0 / 12.0, 35.0], 'K': [0.01, 0.99], 'F': [-0.009, 0.041], 'LnVol': [0.05, 0.25],
+          'Kappa': [0.25, 4.00], 'Theta': [0.05**2, 0.25**2], 'Xi': [0.10, 0.50],
+          'Rho': [-0.40, 0.40]}
+
 # ################ Generate dataset ###############################################################
 print(">> Generate dataset")
 
 print(f"> Generate {NUM_SAMPLES:,} price samples")
 timer_gen = Stopwatch("Generating Samples")
 timer_gen.trigger()
-data_df = generator.generate_samples(NUM_SAMPLES)
+data_df = generator.generate_samples(NUM_SAMPLES, RANGES)
+# full_data_file = os.path.join(data_folder, MODEL_TYPE + "_samples_full.tsv")
+# generator.to_file(data_df, full_data_file)
 timer_gen.stop()
 
 print("> Convert to normal vol and cleanse data")

{sdevpy-0.1.2 → sdevpy-0.1.4}/src/sdevpy/projects/stovol/stovoltrain.py

@@ -13,31 +13,36 @@ from sdevpy.machinelearning.topology import compose_model
 from sdevpy.machinelearning.learningmodel import LearningModel, load_learning_model
 from sdevpy.machinelearning.learningschedules import FlooredExponentialDecay
 from sdevpy.machinelearning.callbacks import RefCallback
-from sdevpy.machinelearning.datasets import prepare_sets
-from sdevpy.tools.filemanager import check_directory
+from sdevpy.machinelearning import datasets
+from sdevpy.tools import filemanager
 from sdevpy.tools.timer import Stopwatch
 from sdevpy.tools import clipboard
-from sdevpy.maths.metrics import rmse, tf_rmse
+from sdevpy.maths.metrics import bps_rmse, tf_bps_rmse
 from sdevpy.volsurfacegen.stovolfactory import set_generator
 from sdevpy.projects.stovol import stovolplot as xplt
 
+
+# Implement DOWNLOAD_DATASET for TRAIN = True
+# Create Colab to generate, Colab to train
 # Fine-train models
-# Use type in json to know which type to instantiate
-# Lazy instantiation from remote/name code
 # Store data in Kaggle
 
 # ################ Runtime configuration ##########################################################
-# MODEL_TYPE = "SABR"
-# MODEL_TYPE = "ShiftedSABR"
-# MODEL_TYPE = "McShiftedSABR"
-MODEL_TYPE = "FbSABR"
-# MODEL_TYPE = "McShiftedZABR"
-# MODEL_TYPE = "McShiftedHeston"
+MODEL_TYPE = "SABR"
+# MODEL_TYPE = "McSABR"
+# MODEL_TYPE = "FbSABR"
+# MODEL_TYPE = "McZABR"
+# MODEL_TYPE = "McHeston"
+MODEL_ID = "SABR_3L_64n" # Pre-trained model ID (we can pre-train several versions)
+SHIFT = 0.03
 USE_TRAINED = True
+DOWNLOAD_MODELS = True # Only used when USE_TRAINED is True
+DOWNLOAD_DATASETS = True # Use when already created/downloaded
 TRAIN = False
 if USE_TRAINED is False and TRAIN is False:
     raise RuntimeError("When not using pre-trained models, a new model must be trained")
 
+NUM_SAMPLES = 500 * 1000 # Number of samples to read from sample files
 TRAIN_PERCENT = 0.90 # Proportion of dataset used for training (rest used for test)
 EPOCHS = 100
 BATCH_SIZE = 1000
@@ -47,35 +52,40 @@ NUM_MC = 100 * 1000 # 100 * 1000
 POINTS_PER_YEAR = 25 # 25
 
 print(">> Set up runtime configuration")
+print("> Chosen model type: " + MODEL_TYPE)
+if USE_TRAINED:
+    print("> Pre-trained model ID: " + MODEL_ID)
+
 project_folder = os.path.join(settings.WORKFOLDER, "stovol")
 print("> Project folder: " + project_folder)
-data_folder = os.path.join(project_folder, "samples")
+sample_folder = os.path.join(project_folder, "samples")
+data_folder = os.path.join(sample_folder, MODEL_TYPE)
 print("> Data folder: " + data_folder)
-check_directory(data_folder)
-print("> Chosen model: " + MODEL_TYPE)
-data_file = os.path.join(data_folder, MODEL_TYPE + "_samples.tsv")
+data_file = os.path.join(sample_folder, MODEL_TYPE + "_samples.tsv")
+print("> Data file: " + data_file)
 model_folder = os.path.join(project_folder, "models")
 print("> Model folder: " + model_folder)
 
-# ################ Helper functions ###############################################################
-def bps_rmse(y_true, y_ref):
-    """ RMSE in bps """
-    return 10000.0 * rmse(y_true, y_ref)
+if USE_TRAINED and DOWNLOAD_MODELS:
+    url = 'https://github.com/sebgur/SDev.Python/raw/main/models/stovol/stovol.zip'
+    print("> Downloading and unzipping models from: " + url)
+    filemanager.download_unzip(url, model_folder)
 
-def tf_bps_rmse(y_true, y_ref):
-    """ RMSE in bps in tensorflow """
-    return 10000.0 * tf_rmse(y_true, y_ref)
+if DOWNLOAD_DATASETS:
+    print("> Downloading datasets from: ")
 
 # ################ Select generator ###############################################################
 # Select generator. The number of expiries and surface size are irrelevant as here we do not
 # generate sample data but read it from files. Number of MC and points per year are required
 # to calculate the reference values against which we can validate the model.
-generator = set_generator(MODEL_TYPE, num_mc=NUM_MC, points_per_year=POINTS_PER_YEAR)
+generator = set_generator(MODEL_TYPE, shift=SHIFT, num_mc=NUM_MC, points_per_year=POINTS_PER_YEAR)
 
 # ################ Prepare datasets ###############################################################
 # Datasets are always read, as even if we don't train, we're still going to evaluate the
 # performance of the pre-trained model
 print(">> Preparing datasets")
+# Retrieve data from dataset folder
+datasets.retrieve_data(data_folder, NUM_SAMPLES, shuffle=True, export_file=data_file)
 # Retrieve dataset
 print("> Reading dataset from file: " + data_file)
 x_set, y_set, data_df = generator.retrieve_datasets(data_file, shuffle=True)
@@ -88,13 +98,15 @@ print(data_df.head())
 # Split into training and test sets
 TRS = TRAIN_PERCENT * 100
 print(f"> Splitting between training set ({TRS:.2f}%) and test set ({100 - TRS:.2f}%)")
-x_train, y_train, x_test, y_test = prepare_sets(x_set, y_set, TRAIN_PERCENT)
+x_train, y_train, x_test, y_test = datasets.prepare_sets(x_set, y_set, TRAIN_PERCENT)
+print(f"> Training set size: {x_train.shape[0]:,}")
+print(f"> Testing set size: {x_test.shape[0]:,}")
 
 # ################ Compose/Load the model #########################################################
 # Compose new model or load pre-trained one
 if USE_TRAINED:
     print(">> Loading pre-trained model")
-    model_folder_name = os.path.join(model_folder, MODEL_TYPE)
+    model_folder_name = os.path.join(model_folder, MODEL_ID)
     print("> Loading pre-trained model from: " + model_folder_name)
     model = load_learning_model(model_folder_name)
     keras_model = model.model
@@ -138,26 +150,19 @@ if TRAIN:
     for field, value in optim_fields.items():
         print("> ", field, ":", value)
 
-
     # Compile
     print("> Compile model")
     keras_model.compile(loss=tf_bps_rmse, optimizer=optimizer)
 
-
     # Callbacks
     EPOCH_SAMPLING = 5
     callback = RefCallback(x_test, y_test, bps_rmse, optimizer=optimizer,
                            epoch_sampling=EPOCH_SAMPLING)
-    # callback = None
-    # callback = SDevPyCallback(optimizer=optimizer, epoch_sampling=EPOCH_SAMPLING)
 
     # Train the network
     print(">> Training ANN model")
     trn_timer = Stopwatch("Training")
     trn_timer.trigger()
-    # shuffled_indices = np.random.permutation(x_train.shape[0])
-    # x_train = x_train[shuffled_indices]
-    # y_train = y_train[shuffled_indices]
     model.train(x_train, y_train, EPOCHS, BATCH_SIZE, callback)
     trn_timer.stop()
     trn_timer.print()
@@ -177,22 +182,23 @@ print(">> Analyse results")
 # Check performance
 train_pred = model.predict(x_train)
 train_rmse = bps_rmse(train_pred, y_train)
-print(f"RMSE(nvol) on training set: {train_rmse:,.2f}")
+print(f"> RMSE(nvol) on training set: {train_rmse:,.2f}")
 
 test_pred = model.predict(x_test)
 test_rmse = bps_rmse(test_pred, y_test)
-print(f"RMSE(nvol) on test set: {test_rmse:,.2f}")
+print(f"> RMSE(nvol) on test set: {test_rmse:,.2f}")
 
 # Generate strike spread axis
 if SHOW_VOL_CHARTS:
+    print("> Choosing a sample parameter set to display chart")
     NUM_STRIKES = 100
     PARAMS = { 'LnVol': 0.20, 'Beta': 0.5, 'Nu': 0.55, 'Rho': -0.25, 'Gamma': 0.7, 'Kappa': 1.0,
                 'Theta': 0.05, 'Xi': 0.50 }
     FWD = 0.028
 
     # Any number of expiries can be calculated, but for optimum display choose no more than 6
-    EXPIRIES = np.asarray([0.125, 0.250, 0.5, 1.00, 2.0, 5.0]).reshape(-1, 1)
-    # EXPIRIES = np.asarray([0.25, 0.50, 1.0, 5.00, 10.0, 30.0]).reshape(-1, 1)
+    # EXPIRIES = np.asarray([0.125, 0.250, 0.5, 1.00, 2.0, 5.0]).reshape(-1, 1)
+    EXPIRIES = np.asarray([0.25, 0.50, 1.0, 5.00, 10.0, 30.0]).reshape(-1, 1)
     NUM_EXPIRIES = EXPIRIES.shape[0]
     METHOD = 'Percentiles'
     PERCENTS = np.linspace(0.01, 0.99, num=NUM_STRIKES)
@@ -204,15 +210,23 @@ if SHOW_VOL_CHARTS:
     # ARE_CALLS = [[False if s < FWD else True for s in expks] for expks in strikes] # Puts/calls
     # print(ARE_CALLS)
 
-    print("Calculating chart surface with reference model")
+    print("> Calculating chart surface with reference model")
+    timer_ref = Stopwatch("Reference surface calculation")
+    timer_ref.trigger()
     ref_prices = generator.price_surface_ref(EXPIRIES, strikes, ARE_CALLS, FWD, PARAMS)
-    # print(ref_prices.shape)
+    timer_ref.stop()
     # clipboard.export2d(ref_prices)
-    print("Calculating chart surface with trained model")
+    print("> Calculating chart surface with trained model")
+    timer_mod = Stopwatch("Model surface calculation")
+    timer_mod.trigger()
     mod_prices = generator.price_surface_mod(model, EXPIRIES, strikes, ARE_CALLS, FWD, PARAMS)
-    # print(mod_prices.shape)
+    timer_mod.stop()
     # clipboard.export2d(mod_prices)
-    print(f"Ref-Mod RMSE(price): {bps_rmse(ref_prices, mod_prices):.2f}")
+    print(f"> Ref-Mod RMSE(price): {bps_rmse(ref_prices, mod_prices):.2f}")
+
+    # Display timers
+    timer_ref.print()
+    timer_mod.print()
 
     # Available tranforms: Price, ShiftedBlackScholes, Bachelier
     TITLE = f"{MODEL_TYPE} smile sections, forward={FWD*100:.2f}"#,%\n parameters={PARAMS}"

{sdevpy-0.1.2 → sdevpy-0.1.4}/src/sdevpy/test.py

@@ -1,16 +1,116 @@
 """ Just to test things """
 # import tensorflow as tf
-import numpy as np
-import scipy.stats as sp
-import json
-import matplotlib.pyplot as plt
-# from maths.metrics import rmse
-# import projects.xsabr_fit.sabrgenerator as sabr
-
-strikes = [1, 2, 3, 4, 5]
-fwd = 2.5
-are_calls = [False if s < fwd else True for s in strikes]
-print(are_calls) 
+# import numpy as np
+# import scipy.stats as sp
+# import json
+# import matplotlib.pyplot as plt
+import requests, zipfile
+import io
+import pandas as pd
+from io import BytesIO
+
+# URL = 'https://drive.google.com/file/d/10dKi82fW2arlKnOahNv9i5igfiydwMnc/view?usp=sharing'
+
+
+# def download_file_from_google_drive(id, destination):
+#     # URL = "https://docs.google.com/uc?export=download"
+
+#     session = requests.Session()
+
+#     print(URL)
+#     print(id)
+#     response = session.get(URL, params = { 'id' : id }, stream = True)
+#     print(response)
+#     token = get_confirm_token(response)
+#     print(token)
+
+#     if token:
+#         params = { 'id' : id, 'confirm' : token }
+#         response = session.get(URL, params = params, stream = True)
+
+#     save_response_content(response, destination)    
+
+# def get_confirm_token(response):
+#     for key, value in response.cookies.items():
+#         if key.startswith('download_warning'):
+#             return value
+
+#     return None
+
+# def save_response_content(response, destination):
+#     CHUNK_SIZE = 32768
+
+#     with open(destination, "wb") as f:
+#         for chunk in response.iter_content(CHUNK_SIZE):
+#             if chunk: # filter out keep-alive new chunks
+#                 f.write(chunk)
+
+
+
+# id = '10dKi82fW2arlKnOahNv9i5igfiydwMnc'
+
+# destination_ = ''
+
+# download_file_from_google_drive(id, destination_)
+
+# sample_url = 'https://1drv.ms/u/s!AivreF7B9rL4kK8Hx1vT4PRjtbE1iA?e=fxM7Kx' # OneDrive
+
+# req = requests.get(sample_url)
+
+# # Extract
+# zipfile = zipfile.ZipFile(BytesIO(req.content))
+# zipfile.extractall('New Folder')
+
+# url = 'https://github.com/sebgur/SDev.Python/raw/main/models/stovol/SABR.zip'
+
+# MODEL_NAME = 'SABR'
+# OUPUT_ROOT = r'C:\temp\sdevpy\stovol\models'
+
+# base_url = 'https://github.com/sebgur/SDev.Python/raw/main/models/stovol/'
+# model_url = base_url + MODEL_NAME + ".zip"
+
+# req = requests.get(model_url)
+
+# filename = url.split('/')[-1]
+# print("Downloading: " + filename)
+
+# # Download
+# with open(filename,'wb') as output_file:
+#     output_file.write(req.content)
+# print('Downloading Completed')
+
+# # Extract
+# zipfile = zipfile.ZipFile(BytesIO(req.content))
+# zipfile.extractall(OUPUT_ROOT)
+
+
+# url = "https://raw.githubusercontent.com/sebgur/SDev.Python/main/samples/McHeston_samples.tsv"
+
+# https://github.com/sebgur/SDev.Python/blob/main/models/stovol/SABR/config.json
+# https://raw.githubusercontent.com/sebgur/SDev.Python/main/models/stovol/SABR/config.json
+
+# https://github.com/sebgur/SDev.Python/tree/main/models/stovol
+# https://raw.githubusercontent.com/sebgur/SDev.Python/main/models/stovol
+
+# download = requests.get(url).content
+
+# df = pd.read_csv(io.StringIO(download.decode('utf-8')), sep='\t')
+# print(df.head())
+
+# parameters = { 'LnVol2': 0.2, 'Beta': 0.5}
+
+# # print(parameters['LnVol'])
+
+# if 'LnVol' in parameters:
+#     print("found it")
+# else:
+#     print("boooo")
+
+
+# strikes = [1, 2, 3, 4, 5]
+# fwd = 2.5
+# are_calls = [False if s < fwd else True for s in strikes]
+# print(are_calls) 
 
 # num_expiries = 2
 # num_strikes = 3

{sdevpy-0.1.2 → sdevpy-0.1.4}/src/sdevpy/tools/filemanager.py

@@ -1,9 +1,27 @@
 """ File management utilities """
 import os
 import csv
-import winsound
-import datetime as dt
+# import datetime as dt
 import pathlib
+from io import BytesIO
+import zipfile as zf
+import requests
+
+
+def download_unzip(zip_url, extract_folder, save_file=False):
+    """ Download zip file from url and unzip """
+    req = requests.get(zip_url, timeout=10)
+
+    if save_file:
+        down_filename = zip_url.split('/')[-1]
+        with open(down_filename,'wb') as output_file:
+            output_file.write(req.content)
+
+    with zf.ZipFile(BytesIO(req.content)) as zip_file:
+        zip_file.extractall(extract_folder)
+
+    # zipfile = zf.ZipFile(BytesIO(req.content))
+    # zipfile.extractall(extract_folder)
 
 
 def check_directory(path):
@@ -31,6 +49,7 @@ def write_csv(file):
 
 #     return files
 
+
 def list_files(path, extensions=None):
     """ List all files in a path that have the extensions """
     all_files = os.listdir(path)
@@ -43,17 +62,3 @@ def list_files(path, extensions=None):
                 files.append(f)
 
         return files
-
-def make_a_noise(beep=True):
-    """ Make a noise """
-    if beep:
-        f1 = 500
-        f2 = 1000
-        duration = 300
-        winsound.Beep(f1, duration)
-        winsound.Beep(f2, duration)
-        winsound.Beep(f1, duration)
-
-    now = dt.datetime.now()
-    dt_string = now.strftime("%H:%M:%S, %d/%m/%Y")
-    print("Closing at ", dt_string)

{sdevpy-0.1.2 → sdevpy-0.1.4}/src/sdevpy/tools/timegrids.py

@@ -24,7 +24,7 @@ class TimeGridBuilder(ABC):
 
     def add_grid(self, times):
         """ Add vector of times """
-        self.time_grid_.extend(times)
+        self.time_grid_.extend(times.reshape(-1))
 
     def refine(self):
         """ Add a fine grid to the current grid """
@@ -82,8 +82,24 @@ if __name__ == "__main__":
     settlement = date(2026, 1, 24)
     builder = SimpleTimeGridBuilder(5)
     builder.add_dates(base, [fixing, settlement, expiry, monitor, settlement])
-    print(builder.time_grid_)
+    # print(builder.time_grid_)
     builder.refine()
-    print(builder.time_grid_)
+    # print(builder.time_grid_)
     builder.clean()
-    print(builder.time_grid_)
+    # print(builder.time_grid_)
+
+    # Test MC situation
+    time_grid_builder = SimpleTimeGridBuilder(points_per_year=5)
+    EXPIRIES = np.asarray([5.0, 1.0, 0.125, 0.250, 0.5]).reshape(-1, 1)
+    print(EXPIRIES)
+    time_grid_builder.add_grid(EXPIRIES)
+    print(time_grid_builder.time_grid_)
+    print("refine")
+    time_grid_builder.refine()
+    print(time_grid_builder.time_grid_)
+    print("clean")
+    time_grid_builder.clean()
+    tg = time_grid_builder.time_grid_
+    print(tg)
+    # time_grid = time_grid_builder.complete_grid()
+