adelorenzo/stable
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Some code improvements. Still some bugs.

Browse Source
This commit is contained in:
Reigo Reinmets
2021-12-09 14:47:44 +02:00
parent 88792852e4
commit fde6779873
3 changed files with 56 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
freqtrade/freqtradebot.py
View File

@@ -450,98 +450,84 @@ class FreqtradeBot(LoggingMixin):
#
# BUY / increase / decrease positions / DCA logic and methods
#
def process_open_trade_positions(self) -> int:
def process_open_trade_positions(self):
"""
Tries to execute additional buy orders for open trades (positions)
Tries to execute additional buy or sell orders for open trades (positions)
"""
orders_created = 0
# Remove pairs for currently opened trades from the whitelist
# Walk through each pair and check if it needs changes
for trade in Trade.get_open_trades():
try:
orders_created += self.adjust_trade_position(trade)
self.adjust_trade_position(trade)
except DependencyException as exception:
logger.warning('Unable to adjust position of trade for %s: %s', trade.pair, exception)
if not orders_created:
logger.debug("Found no trades to modify. Trying again...")
return orders_created
def adjust_trade_position(self, trade: Trade) -> int:
def adjust_trade_position(self, trade: Trade):
"""
Check the implemented trading strategy for adjustment command.
If the pair triggers the adjustment a new buy-order gets issued towards the exchange.
If the strategy triggers the adjustment a new buy/sell-order gets issued.
Once that completes, the existing trade is modified to match new data.
:return: True if a order has been created.
"""
logger.debug(f"adjust_trade_position for pair {trade.pair}")
for order in trade.orders:
if order.ft_is_open:
logger.debug(f"Order {order} is still open.")
return 0
analyzed_df, _ = self.dataprovider.get_analyzed_dataframe(trade.pair, self.strategy.timeframe)
logger.debug(f"Order {order} is still open, skipping pair.")
return
sell_rate = self.exchange.get_rate(trade.pair, refresh=True, side="sell")
current_profit = trade.calc_profit_ratio(sell_rate)
amount_to_adjust = strategy_safe_wrapper(self.strategy.adjust_trade_position, default_retval=0.0)(
amount_to_adjust = strategy_safe_wrapper(self.strategy.adjust_trade_position, default_retval=None)(
pair=trade.pair, trade=trade, current_time=datetime.now(timezone.utc),
current_rate=sell_rate, current_profit=current_profit)
if amount_to_adjust > 0.0:
if amount_to_adjust != None and amount_to_adjust > 0.0:
# We should increase our position
is_order_success = self.execute_trade_position_change(trade.pair, amount_to_adjust, trade)
if is_order_success:
return 1
self.execute_trade_position_change(trade.pair, amount_to_adjust, trade)
if amount_to_adjust < 0.0:
if amount_to_adjust != None and amount_to_adjust < 0.0:
# We should decrease our position
# TODO: Selling part of the trade not implemented yet.
return 0
return
return 0
return
def execute_trade_position_change(self, pair: str, amount: float, trade: Trade) -> bool:
def execute_trade_position_change(self, pair: str, amount: float, trade: Trade):
"""
Executes a limit buy for the given pair
:param pair: pair for which we want to create a LIMIT_BUY
:param stake_amount: amount of stake-currency for the pair
:return: True if a buy order is created, false if it fails.
Executes a buy order for the given pair using specific amount
:param pair: pair for which we want to create a buy order
:param amount: amount of tradable pair to buy
"""
time_in_force = self.strategy.order_time_in_force['buy']
# Calculate price
proposed_enter_rate = self.exchange.get_rate(pair, refresh=True, side="buy")
enter_limit_requested = self.get_valid_price(proposed_enter_rate, proposed_enter_rate)
custom_entry_price = strategy_safe_wrapper(self.strategy.custom_entry_price,
default_retval=proposed_enter_rate)(
pair=pair, current_time=datetime.now(timezone.utc),
proposed_rate=proposed_enter_rate)
enter_limit_requested = self.get_valid_price(custom_entry_price, proposed_enter_rate)
if not enter_limit_requested:
raise PricingError('Could not determine buy price.')
min_stake_amount = self.exchange.get_min_pair_stake_amount(pair, enter_limit_requested,
self.strategy.stoploss)
stake_amount = amount * enter_limit_requested
stake_amount = self.wallets.validate_stake_amount(pair, stake_amount, min_stake_amount)
logger.error(f'Executing DCA buy: amount={amount}, stake={stake_amount}')
stake_amount = self.wallets.validate_stake_amount(pair, (amount * enter_limit_requested), min_stake_amount)
if not stake_amount:
logger.info(f'Additional order failed to get stake amount for pair {pair}, amount={amount}, price={enter_limit_requested}')
return False
logger.debug(f'Executing additional order: amount={amount}, stake={stake_amount}, price={enter_limit_requested}')
amount = self.exchange.amount_to_precision(pair, amount)
order = self.exchange.create_order(pair=pair, ordertype='market', side="buy",
order = self.exchange.create_order(pair=pair, ordertype="market", side="buy",
amount=amount, rate=enter_limit_requested,
time_in_force=time_in_force)
order_obj = Order.parse_from_ccxt_object(order, pair, 'buy')
order_id = order['id']
order_status = order.get('status', None)
# we assume the order is executed at the price requested
enter_limit_filled_price = enter_limit_requested
amount_requested = amount
if order_status == 'expired' or order_status == 'rejected':
order_tif = self.strategy.order_time_in_force['buy']
@@ -563,44 +549,19 @@ class FreqtradeBot(LoggingMixin):
)
stake_amount = order['cost']
amount = safe_value_fallback(order, 'filled', 'amount')
enter_limit_filled_price = safe_value_fallback(order, 'average', 'price')
# in case of FOK the order may be filled immediately and fully
elif order_status == 'closed':
stake_amount = order['cost']
amount = safe_value_fallback(order, 'filled', 'amount')
enter_limit_filled_price = safe_value_fallback(order, 'average', 'price')
# Fee is applied only once because we make a LIMIT_BUY but the final trade will apply the sell fee.
fee = self.exchange.get_fee(symbol=pair, taker_or_maker='maker')
logger.info(f"Trade {pair} DCA order status {order_status}")
total_amount = 0.0
total_stake = 0.0
for tempOrder in trade.orders:
if tempOrder.ft_is_open:
continue
if tempOrder.ft_order_side != 'buy':
# Skip not buy sides
continue
if tempOrder.status == "closed":
tempOrderAmount = safe_value_fallback(order, 'filled', 'amount')
total_amount += tempOrderAmount
total_stake += tempOrder.average * tempOrderAmount
total_amount += amount
total_stake += stake_amount
trade.open_rate = total_stake / total_amount
trade.fee_open += fee
trade.stake_amount = total_stake
trade.amount = total_amount
logger.info(f"Trade {pair} adjustment order status {order_status}")
trade.orders.append(order_obj)
trade.recalc_open_trade_value()
trade.recalc_trade_from_orders()
Trade.commit()
# Updating wallets
@@ -1459,6 +1420,7 @@ class FreqtradeBot(LoggingMixin):
logger.warning("Could not update trade amount: %s", exception)
trade.update(order)
trade.recalc_trade_from_orders()
Trade.commit()
# Updating wallets when order is closed