def run(self, y, x, weights):
self.__y = y
self.__x = x
self.__weights = self.__calc_log_weights(weights=weights)
self.__alpha = not_a_number()
self.__Beta = not_a_number()
if self.__inputs_lengths_are_valid():
valid_records = self.__calc_valid_records()
if valid_records >= 3:
self.__run_model()
self.__data = {"alpha": self.__alpha, "Beta": self.__Beta}
def test_number_nan():
GIVEN("a NaN value")
nan = not_a_number()
WHEN("we test if it is a number")
true = is_a_number(nan)
THEN("it is not")
assert not true
def test_nan_to_num():
GIVEN("a value that is not a number")
nan = not_a_number()
WHEN("we convert the value to a number")
number = not_a_number_to_number(nan)
THEN("it is now the number 0")
assert number == 0
def test_nan():
GIVEN("a value that is not a number")
nan = not_a_number()
WHEN("we check if the value is not a number")
true = is_not_a_number(nan)
THEN("it is")
assert true
def __calc_ex_average_back_price(self, dict):
valid_trades = self.__get_valid_entries(dict.get("ex").get("trd"))
total_size = sum(valid_trades.values())
return (
sum([price * size for price, size in valid_trades.items()]) / total_size
if total_size
else not_a_number()
)
def __calc_ex_average_back_price(self):
total_back_price = sum(
trade.get("size") * trade.get("price")
for trade in self.__traded_volume)
ex_average_back_price = (total_back_price / self.__ex_back_size
if self.__ex_back_size else not_a_number())
return ex_average_back_price
def __calc_ex_average_lay_price(self):
total_lay_price = sum(
calc_sell_liability(price=trade.get("price"),
size=trade.get("size")) *
calc_inverse_price(trade.get("price"))
for trade in self.__traded_volume)
ex_average_lay_price = (total_lay_price / self.__ex_lay_size
if self.__ex_lay_size else not_a_number())
return ex_average_lay_price
def __set_sp_back_price(self):
if any(variable in ["sp_back_price", "sp_lay_price"]
for variable in self.__required_variables):
price = self.__sp.get("nearPrice")
sp_back_price = price if is_valid_price(
price=price) else not_a_number()
else:
sp_back_price = None
self.__sp_back_price = sp_back_price
def _get_log_returns(self, y):
data = make_copy(y)
shifted_list = make_copy(data)
shifted_list.pop()
shifted_list.insert(0, not_a_number())
return [
calculate_log(point_in_time / previous_point_in_time)
for point_in_time, previous_point_in_time in zip(
data, shifted_list)
]
def __calc_ex_average_lay_price(self, dict):
trades = dict.get("ex").get("trd")
valid_trades = self.__get_valid_entries(trades)
liabilities = self.__calc_lay_liabilities(trades)
total_liability = sum(liabilities)
return (
sum(
calc_inverse_price(buy_price) * liability
for buy_price, liability in zip(valid_trades.keys(), liabilities)
)
/ total_liability
if total_liability
else not_a_number()
)
def test_try_divide_nan():
GIVEN("a numerator, a divisor and a NaN value")
numerator = 1
denominator = 2
nan = not_a_number()
WHEN("we try to divide the numerator by NaN")
result = try_divide(value=numerator, denominator=nan)
THEN("the result is as expected")
assert is_not_a_number(result)
WHEN("we try to divide NaN by the denominator")
result = try_divide(value=nan, denominator=denominator)
THEN("the result is as expected")
assert is_not_a_number(result)
WHEN("we try to divide NaN by NaN")
result = try_divide(value=nan, denominator=nan)
THEN("the result is as expected")
assert is_not_a_number(result)
def test_nan_comp_data():
GIVEN("a simple set of data and a data transform handler")
nan = not_a_number()
items = (
{
"id": 123,
"price": 0.476190476190476
},
{
"id": 456,
"price": 0.476190476190476
},
{
"id": 789,
"price": nan
},
)
handler = TransformHandler()
handler._set_items(items=items)
WHEN("we calculate the compositional data")
compositional_data = handler._get_compositional_data(price_name="price")
THEN("a list of dictionaries with the correct values is returned")
assert compositional_data[0:2] == [
{
"id": 123,
"compositional_probability": 0.5,
"compositional_price": 2
},
{
"id": 456,
"compositional_probability": 0.5,
"compositional_price": 2
},
]
nan_entry = compositional_data[2]
assert nan_entry.get("id") == 789
assert is_not_a_number(nan_entry.get("compositional_probability"))
assert is_not_a_number(nan_entry.get("compositional_price"))
def test_nan_comp_data():
GIVEN("a simple set of data and a probability handler")
nan = not_a_number()
items = (
{
"id": 123,
"sp_probability": 0.476190476190476
},
{
"id": 456,
"sp_probability": 0.476190476190476
},
{
"id": 789,
"sp_probability": nan
},
)
handler = ProbabilityHandler(items=items,
name="sp_probability",
correct_probability=1)
WHEN("we calculate the compositional probabilities")
compositional_probabilities = handler.calc_compositional_probabilities()
THEN("a list of dictionaries with the correct values is returned")
assert compositional_probabilities[0:2] == [
{
"id": 123,
"compositional_probability": 0.5
},
{
"id": 456,
"compositional_probability": 0.5
},
]
nan_entry = compositional_probabilities[2]
assert nan_entry.get("id") == 789
assert is_not_a_number(nan_entry.get("compositional_probability"))
def __get_test_dict():
return {
"A": [1, 2, 3, 4, 5.000000],
"B": [7, 8, 9, 10, "11.1234"],
"C": [13, 15, 16, 17, not_a_number()],
}
def __get_ex_ex_offered_back_price(self):
available_to_back = self.__ex.get("availableToBack")
ex_offered_back_price = (available_to_back[0].get("price")
if available_to_back else not_a_number())
return ex_offered_back_price
def __get_ex_ex_offered_lay_price(self):
available_to_lay = self.__ex.get("availableToLay")
ex_offered_lay_price = (available_to_lay[0].get("price")
if available_to_lay else not_a_number())
return ex_offered_lay_price
def __get_removal_date(self):
raw_removal_date = self.__record.get("removalDate")
removal_date = (DateTime(raw_removal_date).get_epoch()
if raw_removal_date else not_a_number())
return removal_date
def try_divide(value, denominator):
return (value / denominator if is_a_number(value)
and __can_divide(denominator) else not_a_number())
def calc_inverse_price(price):
return 1 / (1 - (1 / price)) if is_valid_price(price) else not_a_number()
def _get_min_valid_price(self, dict):
valid_prices = self.__get_valid_prices(dict)
return min(valid_prices) if valid_prices else not_a_number()
