TaskingEye can shoot deep in the book as well
This commit is contained in:
1 parent
9fd7f8a0a6
commit
4dbafcab91
2 files changed
+105
-33
No files matched your search
@@ -300,6 +300,9 @@ extern "C" void init_execution_tester_plugin(bts::SparkServices &srv) {
|
||||
extern "C" void init_task_eye_plugin(bts::SparkServices &srv) {
|
||||
DynamicOrderDescriptor tasking_eye_algo;
|
||||
tasking_eye_algo.set_dynamic_order_type("Tasking Eye");
|
||||
// if this is set to true, it waits for the existance of Signal File
|
||||
*tasking_eye_algo.add_param_desc() = param_bool("Wait For Signal");
|
||||
*tasking_eye_algo.add_param_desc() = param_string("Signal File");
|
||||
*tasking_eye_algo.add_param_desc() = param_string("Account");
|
||||
*tasking_eye_algo.add_param_desc() = param_double("Edge");
|
||||
*tasking_eye_algo.add_param_desc() = param_double("Shot Size");
|
||||
|
||||
@@ -25,8 +25,10 @@
|
||||
#include <boost/algorithm/string.hpp>
|
||||
#include <chrono>
|
||||
#include <elf.h>
|
||||
#include <filesystem>
|
||||
#include <google/protobuf/timestamp.pb.h>
|
||||
#include <google/protobuf/util/time_util.h>
|
||||
#include <iostream>
|
||||
#include <optional>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
@@ -233,6 +235,8 @@ struct TaskingEyeAlgo ::PImpl {
|
||||
IAlgoServices *service_ptr = nullptr;
|
||||
analytics::ITheoCalculator const *theo_calc = nullptr;
|
||||
TEAState state = TEAState::ACTIVE;
|
||||
bool wait_for_signal = false;
|
||||
std::string signal_file = "";
|
||||
double edge = 100000;
|
||||
double shot_size = 0;
|
||||
double target_qty = 0;
|
||||
@@ -266,22 +270,29 @@ TaskingEyeAlgo::~TaskingEyeAlgo() {}
|
||||
OrderOpResult TaskingEyeAlgo::do_before_launch(
|
||||
IBeforeLaunchAlgoServices &serv) {
|
||||
auto is_data_valid = [&]() {
|
||||
return greater_then_eq(0.1, me->shot_size) &&
|
||||
greater_then_eq(1, me->target_qty) &&
|
||||
greater_then_eq(1, me->max_shots_per_window) &&
|
||||
greater_then_eq(1000000000, me->window_size_nanos) &&
|
||||
me->side != api::SIDE_UNDEFINED;
|
||||
bool rv = greater_then_eq(0.1, me->shot_size) &&
|
||||
greater_then_eq(1, me->target_qty) &&
|
||||
greater_then_eq(1, me->max_shots_per_window) &&
|
||||
greater_then_eq(1000000000, me->window_size_nanos) &&
|
||||
me->side != api::SIDE_UNDEFINED;
|
||||
bool signal_correct = !me->wait_for_signal || !me->signal_file.empty();
|
||||
rv = rv && signal_correct;
|
||||
return rv;
|
||||
};
|
||||
LOG(OrderMan, Info,
|
||||
"TaskingEyeAlgo::do_before_launch order_key: {} security: {} "
|
||||
"definition: {}",
|
||||
serv.order_key().value(), utils::pb::to_string(serv.security()),
|
||||
utils::pb::to_string(serv.definition()));
|
||||
// TODO, remove this
|
||||
sleep_log();
|
||||
auto &def = serv.definition();
|
||||
if (def.has_custom_def() && def.custom_def().has_dynamic()) {
|
||||
const auto &d_params = def.custom_def().dynamic().order_params();
|
||||
auto wait_for_signal = get_if<bool>(d_params, "Wait For Signal");
|
||||
me->wait_for_signal =
|
||||
wait_for_signal.has_value() ? wait_for_signal.value() : false;
|
||||
auto signal_file = get_if<std::string>(d_params, "Signal File");
|
||||
me->signal_file = signal_file.has_value() ? signal_file.value() : "";
|
||||
me->edge = get_if<double>(d_params, "Edge").value();
|
||||
LOG(OrderMan, Info, "TaskingEyeAlgo::do_before_launch edge: {}",
|
||||
me->edge);
|
||||
@@ -335,11 +346,12 @@ OrderOpResult TaskingEyeAlgo::do_before_launch(
|
||||
"TaskingEyeAlgo::do_before_launch algo constructed order_key: "
|
||||
"{} "
|
||||
"edge: {} shot_size: {} side: {} target_qty: {} "
|
||||
"max_shots_per_window: {} window_size_nanos: {} n_secs: {}",
|
||||
"max_shots_per_window: {} window_size_nanos: {} n_secs: {} "
|
||||
"wait_for_signal: {} signal_file: {}",
|
||||
serv.order_key(), me->edge, me->shot_size,
|
||||
bts::api::Side_Name(me->side), me->target_qty,
|
||||
me->max_shots_per_window, me->window_size_nanos,
|
||||
me->sec_map.size());
|
||||
me->sec_map.size(), me->wait_for_signal, me->signal_file);
|
||||
return {};
|
||||
}
|
||||
}
|
||||
@@ -458,9 +470,9 @@ void TaskingEyeAlgo::on_theos(
|
||||
if (!sec_data.driver_sec_key.has_value() ||
|
||||
sec_data.driver_sec_key->value() != driver.value()) {
|
||||
LOG(OrderMan, Info,
|
||||
"TaskingEyeAlgo::on_theos order_key: {} subscribing to driver "
|
||||
"sec_key: {}",
|
||||
me->service_ptr->order_key(), driver.value());
|
||||
"TaskingEyeAlgo::on_theos order_key: {} subscribing to driver for "
|
||||
"sec_key: {} driver_key: {}",
|
||||
me->service_ptr->order_key(), sec_key, driver.value());
|
||||
sec_data.driver_sec_key = SecurityKey(driver.value());
|
||||
sub_to_driver(SecurityKey(driver.value()));
|
||||
}
|
||||
@@ -474,8 +486,14 @@ void TaskingEyeAlgo::on_position(PositionUpdate const &pu) {
|
||||
}
|
||||
|
||||
void TaskingEyeAlgo::_evaluate_and_shoot() {
|
||||
if (me->state != TEAState::ACTIVE)
|
||||
if (me->state != TEAState::ACTIVE) {
|
||||
LOG(OrderMan, Warn,
|
||||
"TaskingEyeAlgo::_evaluate_and_shoot order_key: {} state is not "
|
||||
"active state: {} ",
|
||||
me->service_ptr->order_key(), me->state);
|
||||
return;
|
||||
}
|
||||
|
||||
auto max_shots_per_win_reached = [&]() {
|
||||
return n_recent_shots(me->shots, me->window_size_nanos) >=
|
||||
me->max_shots_per_window;
|
||||
@@ -486,12 +504,36 @@ void TaskingEyeAlgo::_evaluate_and_shoot() {
|
||||
return true;
|
||||
return false;
|
||||
};
|
||||
auto signal_condition_met = [&]() {
|
||||
if (me->wait_for_signal) {
|
||||
return std::filesystem::exists(me->signal_file);
|
||||
} else
|
||||
return true;
|
||||
};
|
||||
if (!signal_condition_met()) {
|
||||
// Log ?
|
||||
LOG(OrderMan, Warn,
|
||||
"TaskingEyeAlgo::_evaluate_and_shoot order_key: {} Waiting for "
|
||||
"Signal",
|
||||
me->service_ptr->order_key());
|
||||
return;
|
||||
}
|
||||
for (auto &kv : me->sec_map) {
|
||||
auto sec_key = kv.first;
|
||||
if (max_shots_per_win_reached())
|
||||
if (max_shots_per_win_reached()) {
|
||||
LOG(OrderMan, Warn,
|
||||
"TaskingEyeAlgo::_evaluate_and_shoot order_key: {} "
|
||||
"max_shots_per_win_reached",
|
||||
me->service_ptr->order_key());
|
||||
return;
|
||||
if (sec_has_active_order(sec_key))
|
||||
}
|
||||
if (sec_has_active_order(sec_key)) {
|
||||
LOG(OrderMan, Warn,
|
||||
"TaskingEyeAlgo::_evaluate_and_shoot sec_key: {} has working "
|
||||
"order, skipping",
|
||||
sec_key.value());
|
||||
continue;
|
||||
}
|
||||
Price price;
|
||||
Quantity qty;
|
||||
if (_in_shooting_zone(sec_key, price, qty)) {
|
||||
@@ -519,8 +561,13 @@ bool TaskingEyeAlgo::_in_shooting_zone(
|
||||
TEASecData const &sec_data = it->second;
|
||||
const md::PriceSize &driver_bid = sec_data.driver_book.bid().at(0);
|
||||
const md::PriceSize &driver_ask = sec_data.driver_book.ask().at(0);
|
||||
if (eq(driver_bid.size(), 0) || eq(driver_ask.size(), 0))
|
||||
if (eq(driver_bid.size(), 0) || eq(driver_ask.size(), 0)) {
|
||||
LOG(OrderMan, Warn,
|
||||
"TaskingEyeAlgo::_in_shooting_zone no driver for sec_key: {} "
|
||||
"driver_bid_qty: {} driver_ask_qty: {}",
|
||||
sec_key, driver_bid.size(), driver_ask.size());
|
||||
return false;
|
||||
}
|
||||
// finding weighted mean (TODO change it to mark price later)
|
||||
double driver = (driver_bid.price() * driver_bid.size() +
|
||||
driver_ask.price() * driver_ask.size()) /
|
||||
@@ -530,33 +577,55 @@ bool TaskingEyeAlgo::_in_shooting_zone(
|
||||
// TODO normalize theo
|
||||
double theo = ptp.theo();
|
||||
theo = theo / driver;
|
||||
if (me->side == api::SIDE_BUY) {
|
||||
// auto analyze_buy =
|
||||
auto analyze_buy = [&](const md::PriceSize &md_ask, double theo,
|
||||
size_t level, Price &price, Quantity &qty) -> bool {
|
||||
double ee_buy_pr = theo - me->edge;
|
||||
const md::PriceSize &md_ask = sec_data.sec_book.ask().at(0);
|
||||
LOG(OrderMan, Diag,
|
||||
"TaskingEyeAlgo::_in_shooting_zone sec_key: {} driver: {} theo: "
|
||||
"{} "
|
||||
"ee_price: {} md: {}/{}",
|
||||
sec_key, driver, theo, ee_buy_pr, md_ask.price(), md_ask.size());
|
||||
bool rv = false;
|
||||
if (greater_then_eq(1, md_ask.size()) &&
|
||||
greater_then_eq(md_ask.price(), ee_buy_pr)) {
|
||||
price = Price(md_ask.price());
|
||||
qty = std::min(static_cast<double>(md_ask.size()), me->shot_size);
|
||||
return true;
|
||||
qty = me->shot_size;
|
||||
rv = true;
|
||||
}
|
||||
} else {
|
||||
double ee_sell_pr = theo + me->edge;
|
||||
const md::PriceSize &md_bid = sec_data.sec_book.bid().at(0);
|
||||
LOG(OrderMan, Diag,
|
||||
"TaskingEyeAlgo::_in_shooting_zone sec_key: {} driver: {} theo: "
|
||||
"{} "
|
||||
"ee_price: {} md: {}/{}",
|
||||
sec_key, driver, theo, ee_sell_pr, md_bid.price(), md_bid.size());
|
||||
"TaskingEyeAlgo::_in_shooting_zone::analyze_buy sec_key: {} "
|
||||
"theo: {} level: {}"
|
||||
"ee_buy_pr: {} rv: {}",
|
||||
sec_key, level, theo, ee_buy_pr, rv);
|
||||
return rv;
|
||||
};
|
||||
auto analyze_sell = [&](const md::PriceSize &md_bid, double theo,
|
||||
size_t level, Price &price, Quantity &qty) -> bool {
|
||||
double ee_sell_pr = theo + me->edge;
|
||||
bool rv = false;
|
||||
if (greater_then_eq(1, md_bid.size()) &&
|
||||
greater_then_eq(ee_sell_pr, md_bid.price())) {
|
||||
price = Price(md_bid.price());
|
||||
qty = std::min(static_cast<double>(md_bid.size()), me->shot_size);
|
||||
return true;
|
||||
qty = me->shot_size;
|
||||
rv = true;
|
||||
}
|
||||
LOG(OrderMan, Diag,
|
||||
"TaskingEyeAlgo::_in_shooting_zone::analyze_sell sec_key: {} theo:"
|
||||
"{} level: {} ee_sell_pr: {} rv: {}",
|
||||
sec_key, theo, level, ee_sell_pr, rv);
|
||||
return rv;
|
||||
};
|
||||
if (me->side == api::SIDE_BUY) {
|
||||
const auto &ask_book = sec_data.sec_book.ask();
|
||||
for (int i = ask_book.size() - 1; i >= 0; i--) {
|
||||
const auto &md_ask = ask_book.at(i);
|
||||
if (analyze_buy(md_ask, theo, i, price, qty)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
const auto &bid_book = sec_data.sec_book.bid();
|
||||
for (int i = bid_book.size() - 1; i >= 0; i--) {
|
||||
const md::PriceSize &md_bid = bid_book.at(i);
|
||||
if (analyze_sell(md_bid, theo, i, price, qty)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
|
||||
Reference in new issue
Block a user