6181253459

Committed 08 Sep 2023 06:04AM UTC coverage: 94.614% (+0.06%) from 94.556%

Build # 6181253459

Build Type

push

github-actions

Committed by

web-flow

Commit Message

Merge pull request #9159 from stash86/fix-adjust

remove old codes when we only can do partial entries

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

19114 of 20202 relevant lines covered (94.61%)

0.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.59

/freqtrade/rpc/api_server/api_v1.py

import logging
from copy import deepcopy
from typing import List, Optional

from fastapi import APIRouter, Depends, Query
from fastapi.exceptions import HTTPException

from freqtrade import __version__
from freqtrade.data.history import get_datahandler
from freqtrade.enums import CandleType, TradingMode
from freqtrade.exceptions import OperationalException
from freqtrade.rpc import RPC
from freqtrade.rpc.api_server.api_schemas import (AvailablePairs, Balances, BlacklistPayload,
                                                  BlacklistResponse, Count, DailyWeeklyMonthly,
                                                  DeleteLockRequest, DeleteTrade,
                                                  ExchangeListResponse, ForceEnterPayload,
                                                  ForceEnterResponse, ForceExitPayload,
                                                  FreqAIModelListResponse, Health, Locks, Logs,
                                                  OpenTradeSchema, PairHistory, PerformanceEntry,
                                                  Ping, PlotConfig, Profit, ResultMsg, ShowConfig,
                                                  Stats, StatusMsg, StrategyListResponse,
                                                  StrategyResponse, SysInfo, Version,
                                                  WhitelistResponse)
from freqtrade.rpc.api_server.deps import get_config, get_exchange, get_rpc, get_rpc_optional
from freqtrade.rpc.rpc import RPCException


logger = logging.getLogger(__name__)

# API version
# Pre-1.1, no version was provided
# Version increments should happen in "small" steps (1.1, 1.12, ...) unless big changes happen.
# 1.11: forcebuy and forcesell accept ordertype
# 1.12: add blacklist delete endpoint
# 1.13: forcebuy supports stake_amount
# versions 2.xx -> futures/short branch
# 2.14: Add entry/exit orders to trade response
# 2.15: Add backtest history endpoints
# 2.16: Additional daily metrics
# 2.17: Forceentry - leverage, partial force_exit
# 2.20: Add websocket endpoints
# 2.21: Add new_candle messagetype
# 2.22: Add FreqAI to backtesting
# 2.23: Allow plot config request in webserver mode
# 2.24: Add cancel_open_order endpoint
# 2.25: Add several profit values to /status endpoint
# 2.26: increase /balance output
# 2.27: Add /trades/<id>/reload endpoint
# 2.28: Switch reload endpoint to Post
# 2.29: Add /exchanges endpoint
# 2.30: new /pairlists endpoint
# 2.31: new /backtest/history/ delete endpoint
# 2.32: new /backtest/history/ patch endpoint
# 2.33: Additional weekly/monthly metrics
API_VERSION = 2.33

# Public API, requires no auth.
router_public = APIRouter()
# Private API, protected by authentication
router = APIRouter()


@router_public.get('/ping', response_model=Ping)
def ping():
    """simple ping"""
    return {"status": "pong"}


@router.get('/version', response_model=Version, tags=['info'])
def version():
    """ Bot Version info"""
    return {"version": __version__}


@router.get('/balance', response_model=Balances, tags=['info'])
def balance(rpc: RPC = Depends(get_rpc), config=Depends(get_config)):
    """Account Balances"""
    return rpc._rpc_balance(config['stake_currency'], config.get('fiat_display_currency', ''),)


@router.get('/count', response_model=Count, tags=['info'])
def count(rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_count()


@router.get('/performance', response_model=List[PerformanceEntry], tags=['info'])
def performance(rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_performance()


@router.get('/profit', response_model=Profit, tags=['info'])
def profit(rpc: RPC = Depends(get_rpc), config=Depends(get_config)):
    return rpc._rpc_trade_statistics(config['stake_currency'],
                                     config.get('fiat_display_currency')
                                     )


@router.get('/stats', response_model=Stats, tags=['info'])
def stats(rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_stats()


@router.get('/daily', response_model=DailyWeeklyMonthly, tags=['info'])
def daily(timescale: int = 7, rpc: RPC = Depends(get_rpc), config=Depends(get_config)):
    return rpc._rpc_timeunit_profit(timescale, config['stake_currency'],
                                    config.get('fiat_display_currency', ''))


@router.get('/weekly', response_model=DailyWeeklyMonthly, tags=['info'])
def weekly(timescale: int = 4, rpc: RPC = Depends(get_rpc), config=Depends(get_config)):
    return rpc._rpc_timeunit_profit(timescale, config['stake_currency'],
                                    config.get('fiat_display_currency', ''), 'weeks')


@router.get('/monthly', response_model=DailyWeeklyMonthly, tags=['info'])
def monthly(timescale: int = 3, rpc: RPC = Depends(get_rpc), config=Depends(get_config)):
    return rpc._rpc_timeunit_profit(timescale, config['stake_currency'],
                                    config.get('fiat_display_currency', ''), 'months')


@router.get('/status', response_model=List[OpenTradeSchema], tags=['info'])
def status(rpc: RPC = Depends(get_rpc)):
    try:
        return rpc._rpc_trade_status()
    except RPCException:
        return []


# Using the responsemodel here will cause a ~100% increase in response time (from 1s to 2s)
# on big databases. Correct response model: response_model=TradeResponse,
@router.get('/trades', tags=['info', 'trading'])
def trades(limit: int = 500, offset: int = 0, rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_trade_history(limit, offset=offset, order_by_id=True)


@router.get('/trade/{tradeid}', response_model=OpenTradeSchema, tags=['info', 'trading'])
def trade(tradeid: int = 0, rpc: RPC = Depends(get_rpc)):
    try:
        return rpc._rpc_trade_status([tradeid])[0]
    except (RPCException, KeyError):
        raise HTTPException(status_code=404, detail='Trade not found.')


@router.delete('/trades/{tradeid}', response_model=DeleteTrade, tags=['info', 'trading'])
def trades_delete(tradeid: int, rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_delete(tradeid)


@router.delete('/trades/{tradeid}/open-order', response_model=OpenTradeSchema,  tags=['trading'])
def trade_cancel_open_order(tradeid: int, rpc: RPC = Depends(get_rpc)):
    rpc._rpc_cancel_open_order(tradeid)
    return rpc._rpc_trade_status([tradeid])[0]


@router.post('/trades/{tradeid}/reload', response_model=OpenTradeSchema,  tags=['trading'])
def trade_reload(tradeid: int, rpc: RPC = Depends(get_rpc)):
    rpc._rpc_reload_trade_from_exchange(tradeid)
    return rpc._rpc_trade_status([tradeid])[0]


# TODO: Missing response model
@router.get('/edge', tags=['info'])
def edge(rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_edge()


@router.get('/show_config', response_model=ShowConfig, tags=['info'])
def show_config(rpc: Optional[RPC] = Depends(get_rpc_optional), config=Depends(get_config)):
    state = ''
    strategy_version = None
    if rpc:
        state = rpc._freqtrade.state
        strategy_version = rpc._freqtrade.strategy.version()
    resp = RPC._rpc_show_config(config, state, strategy_version)
    resp['api_version'] = API_VERSION
    return resp


# /forcebuy is deprecated with short addition. use /forceentry instead
@router.post('/forceenter', response_model=ForceEnterResponse, tags=['trading'])
@router.post('/forcebuy', response_model=ForceEnterResponse, tags=['trading'])
def force_entry(payload: ForceEnterPayload, rpc: RPC = Depends(get_rpc)):
    ordertype = payload.ordertype.value if payload.ordertype else None

    trade = rpc._rpc_force_entry(payload.pair, payload.price, order_side=payload.side,
                                 order_type=ordertype, stake_amount=payload.stakeamount,
                                 enter_tag=payload.entry_tag or 'force_entry',
                                 leverage=payload.leverage)

    if trade:
        return ForceEnterResponse.model_validate(trade.to_json())
    else:
        return ForceEnterResponse.model_validate(
            {"status": f"Error entering {payload.side} trade for pair {payload.pair}."})


# /forcesell is deprecated with short addition. use /forceexit instead
@router.post('/forceexit', response_model=ResultMsg, tags=['trading'])
@router.post('/forcesell', response_model=ResultMsg, tags=['trading'])
def forceexit(payload: ForceExitPayload, rpc: RPC = Depends(get_rpc)):
    ordertype = payload.ordertype.value if payload.ordertype else None
    return rpc._rpc_force_exit(payload.tradeid, ordertype, amount=payload.amount)


@router.get('/blacklist', response_model=BlacklistResponse, tags=['info', 'pairlist'])
def blacklist(rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_blacklist()


@router.post('/blacklist', response_model=BlacklistResponse, tags=['info', 'pairlist'])
def blacklist_post(payload: BlacklistPayload, rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_blacklist(payload.blacklist)


@router.delete('/blacklist', response_model=BlacklistResponse, tags=['info', 'pairlist'])
def blacklist_delete(pairs_to_delete: List[str] = Query([]), rpc: RPC = Depends(get_rpc)):
    """Provide a list of pairs to delete from the blacklist"""

    return rpc._rpc_blacklist_delete(pairs_to_delete)


@router.get('/whitelist', response_model=WhitelistResponse, tags=['info', 'pairlist'])
def whitelist(rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_whitelist()


@router.get('/locks', response_model=Locks, tags=['info', 'locks'])
def locks(rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_locks()


@router.delete('/locks/{lockid}', response_model=Locks, tags=['info', 'locks'])
def delete_lock(lockid: int, rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_delete_lock(lockid=lockid)


@router.post('/locks/delete', response_model=Locks, tags=['info', 'locks'])
def delete_lock_pair(payload: DeleteLockRequest, rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_delete_lock(lockid=payload.lockid, pair=payload.pair)


@router.get('/logs', response_model=Logs, tags=['info'])
def logs(limit: Optional[int] = None):
    return RPC._rpc_get_logs(limit)


@router.post('/start', response_model=StatusMsg, tags=['botcontrol'])
def start(rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_start()


@router.post('/stop', response_model=StatusMsg, tags=['botcontrol'])
def stop(rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_stop()


@router.post('/stopentry', response_model=StatusMsg, tags=['botcontrol'])
@router.post('/stopbuy', response_model=StatusMsg, tags=['botcontrol'])
def stop_buy(rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_stopentry()


@router.post('/reload_config', response_model=StatusMsg, tags=['botcontrol'])
def reload_config(rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_reload_config()


@router.get('/pair_candles', response_model=PairHistory, tags=['candle data'])
def pair_candles(
        pair: str, timeframe: str, limit: Optional[int] = None, rpc: RPC = Depends(get_rpc)):
    return rpc._rpc_analysed_dataframe(pair, timeframe, limit)


@router.get('/pair_history', response_model=PairHistory, tags=['candle data'])
def pair_history(pair: str, timeframe: str, timerange: str, strategy: str,
                 freqaimodel: Optional[str] = None,
                 config=Depends(get_config), exchange=Depends(get_exchange)):
    # The initial call to this endpoint can be slow, as it may need to initialize
    # the exchange class.
    config = deepcopy(config)
    config.update({
        'strategy': strategy,
        'timerange': timerange,
        'freqaimodel': freqaimodel if freqaimodel else config.get('freqaimodel'),
    })
    try:
        return RPC._rpc_analysed_history_full(config, pair, timeframe, exchange)
    except Exception as e:
        raise HTTPException(status_code=502, detail=str(e))


@router.get('/plot_config', response_model=PlotConfig, tags=['candle data'])
def plot_config(strategy: Optional[str] = None, config=Depends(get_config),
                rpc: Optional[RPC] = Depends(get_rpc_optional)):
    if not strategy:
        if not rpc:
            raise RPCException("Strategy is mandatory in webserver mode.")
        return PlotConfig.model_validate(rpc._rpc_plot_config())
    else:
        config1 = deepcopy(config)
        config1.update({
            'strategy': strategy
        })
    try:
        return PlotConfig.model_validate(RPC._rpc_plot_config_with_strategy(config1))
    except Exception as e:
        raise HTTPException(status_code=502, detail=str(e))


@router.get('/strategies', response_model=StrategyListResponse, tags=['strategy'])
def list_strategies(config=Depends(get_config)):
    from freqtrade.resolvers.strategy_resolver import StrategyResolver
    strategies = StrategyResolver.search_all_objects(
        config, False, config.get('recursive_strategy_search', False))
    strategies = sorted(strategies, key=lambda x: x['name'])

    return {'strategies': [x['name'] for x in strategies]}


@router.get('/strategy/{strategy}', response_model=StrategyResponse, tags=['strategy'])
def get_strategy(strategy: str, config=Depends(get_config)):
    if ":" in strategy:
        raise HTTPException(status_code=500, detail="base64 encoded strategies are not allowed.")

    config_ = deepcopy(config)
    from freqtrade.resolvers.strategy_resolver import StrategyResolver
    try:
        strategy_obj = StrategyResolver._load_strategy(strategy, config_,
                                                       extra_dir=config_.get('strategy_path'))
    except OperationalException:
        raise HTTPException(status_code=404, detail='Strategy not found')
    except Exception as e:
        raise HTTPException(status_code=502, detail=str(e))
    return {
        'strategy': strategy_obj.get_strategy_name(),
        'code': strategy_obj.__source__,
    }


@router.get('/exchanges', response_model=ExchangeListResponse, tags=[])
def list_exchanges(config=Depends(get_config)):
    from freqtrade.exchange import list_available_exchanges
    exchanges = list_available_exchanges(config)
    return {
        'exchanges': exchanges,
    }


@router.get('/freqaimodels', response_model=FreqAIModelListResponse, tags=['freqai'])
def list_freqaimodels(config=Depends(get_config)):
    from freqtrade.resolvers.freqaimodel_resolver import FreqaiModelResolver
    models = FreqaiModelResolver.search_all_objects(
        config, False)
    models = sorted(models, key=lambda x: x['name'])

    return {'freqaimodels': [x['name'] for x in models]}


@router.get('/available_pairs', response_model=AvailablePairs, tags=['candle data'])
def list_available_pairs(timeframe: Optional[str] = None, stake_currency: Optional[str] = None,
                         candletype: Optional[CandleType] = None, config=Depends(get_config)):

    dh = get_datahandler(config['datadir'], config.get('dataformat_ohlcv'))
    trading_mode: TradingMode = config.get('trading_mode', TradingMode.SPOT)
    pair_interval = dh.ohlcv_get_available_data(config['datadir'], trading_mode)

    if timeframe:
        pair_interval = [pair for pair in pair_interval if pair[1] == timeframe]
    if stake_currency:
        pair_interval = [pair for pair in pair_interval if pair[0].endswith(stake_currency)]
    if candletype:
        pair_interval = [pair for pair in pair_interval if pair[2] == candletype]
    else:
        candle_type = CandleType.get_default(trading_mode)
        pair_interval = [pair for pair in pair_interval if pair[2] == candle_type]

    pair_interval = sorted(pair_interval, key=lambda x: x[0])

    pairs = list({x[0] for x in pair_interval})
    pairs.sort()
    result = {
        'length': len(pairs),
        'pairs': pairs,
        'pair_interval': pair_interval,
    }
    return result


@router.get('/sysinfo', response_model=SysInfo, tags=['info'])
def sysinfo():
    return RPC._rpc_sysinfo()


@router.get('/health', response_model=Health, tags=['info'])
def health(rpc: RPC = Depends(get_rpc)):
    return rpc.health()

1	import logging	1✔
2	from copy import deepcopy	1✔
3	from typing import List, Optional	1✔
4
5	from fastapi import APIRouter, Depends, Query	1✔
6	from fastapi.exceptions import HTTPException	1✔
7
8	from freqtrade import __version__	1✔
9	from freqtrade.data.history import get_datahandler	1✔
10	from freqtrade.enums import CandleType, TradingMode	1✔
11	from freqtrade.exceptions import OperationalException	1✔
12	from freqtrade.rpc import RPC	1✔
13	from freqtrade.rpc.api_server.api_schemas import (AvailablePairs, Balances, BlacklistPayload,	1✔
14	BlacklistResponse, Count, DailyWeeklyMonthly,
15	DeleteLockRequest, DeleteTrade,
16	ExchangeListResponse, ForceEnterPayload,
17	ForceEnterResponse, ForceExitPayload,
18	FreqAIModelListResponse, Health, Locks, Logs,
19	OpenTradeSchema, PairHistory, PerformanceEntry,
20	Ping, PlotConfig, Profit, ResultMsg, ShowConfig,
21	Stats, StatusMsg, StrategyListResponse,
22	StrategyResponse, SysInfo, Version,
23	WhitelistResponse)
24	from freqtrade.rpc.api_server.deps import get_config, get_exchange, get_rpc, get_rpc_optional	1✔
25	from freqtrade.rpc.rpc import RPCException	1✔
26
27
28	logger = logging.getLogger(__name__)	1✔
29
30	# API version
31	# Pre-1.1, no version was provided
32	# Version increments should happen in "small" steps (1.1, 1.12, ...) unless big changes happen.
33	# 1.11: forcebuy and forcesell accept ordertype
34	# 1.12: add blacklist delete endpoint
35	# 1.13: forcebuy supports stake_amount
36	# versions 2.xx -> futures/short branch
37	# 2.14: Add entry/exit orders to trade response
38	# 2.15: Add backtest history endpoints
39	# 2.16: Additional daily metrics
40	# 2.17: Forceentry - leverage, partial force_exit
41	# 2.20: Add websocket endpoints
42	# 2.21: Add new_candle messagetype
43	# 2.22: Add FreqAI to backtesting
44	# 2.23: Allow plot config request in webserver mode
45	# 2.24: Add cancel_open_order endpoint
46	# 2.25: Add several profit values to /status endpoint
47	# 2.26: increase /balance output
48	# 2.27: Add /trades/<id>/reload endpoint
49	# 2.28: Switch reload endpoint to Post
50	# 2.29: Add /exchanges endpoint
51	# 2.30: new /pairlists endpoint
52	# 2.31: new /backtest/history/ delete endpoint
53	# 2.32: new /backtest/history/ patch endpoint
54	# 2.33: Additional weekly/monthly metrics
55	API_VERSION = 2.33	1✔
56
57	# Public API, requires no auth.
58	router_public = APIRouter()	1✔
59	# Private API, protected by authentication
60	router = APIRouter()	1✔
61
62
63	@router_public.get('/ping', response_model=Ping)	1✔
64	def ping():	1✔
65	"""simple ping"""
66	return {"status": "pong"}	1✔
67
68
69	@router.get('/version', response_model=Version, tags=['info'])	1✔
70	def version():	1✔
71	""" Bot Version info"""
72	return {"version": __version__}	1✔
73
74
75	@router.get('/balance', response_model=Balances, tags=['info'])	1✔
76	def balance(rpc: RPC = Depends(get_rpc), config=Depends(get_config)):	1✔
77	"""Account Balances"""
78	return rpc._rpc_balance(config['stake_currency'], config.get('fiat_display_currency', ''),)	1✔
79
80
81	@router.get('/count', response_model=Count, tags=['info'])	1✔
82	def count(rpc: RPC = Depends(get_rpc)):	1✔
83	return rpc._rpc_count()	1✔
84
85
86	@router.get('/performance', response_model=List[PerformanceEntry], tags=['info'])	1✔
87	def performance(rpc: RPC = Depends(get_rpc)):	1✔
88	return rpc._rpc_performance()	1✔
89
90
91	@router.get('/profit', response_model=Profit, tags=['info'])	1✔
92	def profit(rpc: RPC = Depends(get_rpc), config=Depends(get_config)):	1✔
93	return rpc._rpc_trade_statistics(config['stake_currency'],	1✔
94	config.get('fiat_display_currency')
95	)
96
97
98	@router.get('/stats', response_model=Stats, tags=['info'])	1✔
99	def stats(rpc: RPC = Depends(get_rpc)):	1✔
100	return rpc._rpc_stats()	1✔
101
102
103	@router.get('/daily', response_model=DailyWeeklyMonthly, tags=['info'])	1✔
104	def daily(timescale: int = 7, rpc: RPC = Depends(get_rpc), config=Depends(get_config)):	1✔
105	return rpc._rpc_timeunit_profit(timescale, config['stake_currency'],	1✔
106	config.get('fiat_display_currency', ''))
107
108
109	@router.get('/weekly', response_model=DailyWeeklyMonthly, tags=['info'])	1✔
110	def weekly(timescale: int = 4, rpc: RPC = Depends(get_rpc), config=Depends(get_config)):	1✔
111	return rpc._rpc_timeunit_profit(timescale, config['stake_currency'],	1✔
112	config.get('fiat_display_currency', ''), 'weeks')
113
114
115	@router.get('/monthly', response_model=DailyWeeklyMonthly, tags=['info'])	1✔
116	def monthly(timescale: int = 3, rpc: RPC = Depends(get_rpc), config=Depends(get_config)):	1✔
117	return rpc._rpc_timeunit_profit(timescale, config['stake_currency'],	1✔
118	config.get('fiat_display_currency', ''), 'months')
119
120
121	@router.get('/status', response_model=List[OpenTradeSchema], tags=['info'])	1✔
122	def status(rpc: RPC = Depends(get_rpc)):	1✔
123	try:	1✔
124	return rpc._rpc_trade_status()	1✔
125	except RPCException:	1✔
126	return []	1✔
127
128
129	# Using the responsemodel here will cause a ~100% increase in response time (from 1s to 2s)
130	# on big databases. Correct response model: response_model=TradeResponse,
131	@router.get('/trades', tags=['info', 'trading'])	1✔
132	def trades(limit: int = 500, offset: int = 0, rpc: RPC = Depends(get_rpc)):	1✔
133	return rpc._rpc_trade_history(limit, offset=offset, order_by_id=True)	1✔
134
135
136	@router.get('/trade/{tradeid}', response_model=OpenTradeSchema, tags=['info', 'trading'])	1✔
137	def trade(tradeid: int = 0, rpc: RPC = Depends(get_rpc)):	1✔
138	try:	1✔
139	return rpc._rpc_trade_status([tradeid])[0]	1✔
140	except (RPCException, KeyError):	1✔
141	raise HTTPException(status_code=404, detail='Trade not found.')	1✔
142
143
144	@router.delete('/trades/{tradeid}', response_model=DeleteTrade, tags=['info', 'trading'])	1✔
145	def trades_delete(tradeid: int, rpc: RPC = Depends(get_rpc)):	1✔
146	return rpc._rpc_delete(tradeid)	1✔
147
148
149	@router.delete('/trades/{tradeid}/open-order', response_model=OpenTradeSchema, tags=['trading'])	1✔
150	def trade_cancel_open_order(tradeid: int, rpc: RPC = Depends(get_rpc)):	1✔
151	rpc._rpc_cancel_open_order(tradeid)	1✔
152	return rpc._rpc_trade_status([tradeid])[0]	1✔
153
154
155	@router.post('/trades/{tradeid}/reload', response_model=OpenTradeSchema, tags=['trading'])	1✔
156	def trade_reload(tradeid: int, rpc: RPC = Depends(get_rpc)):	1✔
157	rpc._rpc_reload_trade_from_exchange(tradeid)	1✔
158	return rpc._rpc_trade_status([tradeid])[0]	1✔
159
160
161	# TODO: Missing response model
162	@router.get('/edge', tags=['info'])	1✔
163	def edge(rpc: RPC = Depends(get_rpc)):	1✔
164	return rpc._rpc_edge()	1✔
165
166
167	@router.get('/show_config', response_model=ShowConfig, tags=['info'])	1✔
168	def show_config(rpc: Optional[RPC] = Depends(get_rpc_optional), config=Depends(get_config)):	1✔
169	state = ''	1✔
170	strategy_version = None	1✔
171	if rpc:	1✔
172	state = rpc._freqtrade.state	1✔
173	strategy_version = rpc._freqtrade.strategy.version()	1✔
174	resp = RPC._rpc_show_config(config, state, strategy_version)	1✔
175	resp['api_version'] = API_VERSION	1✔
176	return resp	1✔
177
178
179	# /forcebuy is deprecated with short addition. use /forceentry instead
180	@router.post('/forceenter', response_model=ForceEnterResponse, tags=['trading'])	1✔
181	@router.post('/forcebuy', response_model=ForceEnterResponse, tags=['trading'])	1✔
182	def force_entry(payload: ForceEnterPayload, rpc: RPC = Depends(get_rpc)):	1✔
183	ordertype = payload.ordertype.value if payload.ordertype else None	1✔
184
185	trade = rpc._rpc_force_entry(payload.pair, payload.price, order_side=payload.side,	1✔
186	order_type=ordertype, stake_amount=payload.stakeamount,
187	enter_tag=payload.entry_tag or 'force_entry',
188	leverage=payload.leverage)
189
190	if trade:	1✔
191	return ForceEnterResponse.model_validate(trade.to_json())	1✔
192	else:
193	return ForceEnterResponse.model_validate(	1✔
194	{"status": f"Error entering {payload.side} trade for pair {payload.pair}."})
195
196
197	# /forcesell is deprecated with short addition. use /forceexit instead
198	@router.post('/forceexit', response_model=ResultMsg, tags=['trading'])	1✔
199	@router.post('/forcesell', response_model=ResultMsg, tags=['trading'])	1✔
200	def forceexit(payload: ForceExitPayload, rpc: RPC = Depends(get_rpc)):	1✔
201	ordertype = payload.ordertype.value if payload.ordertype else None	1✔
202	return rpc._rpc_force_exit(payload.tradeid, ordertype, amount=payload.amount)	1✔
203
204
205	@router.get('/blacklist', response_model=BlacklistResponse, tags=['info', 'pairlist'])	1✔
206	def blacklist(rpc: RPC = Depends(get_rpc)):	1✔
207	return rpc._rpc_blacklist()	1✔
208
209
210	@router.post('/blacklist', response_model=BlacklistResponse, tags=['info', 'pairlist'])	1✔
211	def blacklist_post(payload: BlacklistPayload, rpc: RPC = Depends(get_rpc)):	1✔
212	return rpc._rpc_blacklist(payload.blacklist)	1✔
213
214
215	@router.delete('/blacklist', response_model=BlacklistResponse, tags=['info', 'pairlist'])	1✔
216	def blacklist_delete(pairs_to_delete: List[str] = Query([]), rpc: RPC = Depends(get_rpc)):	1✔
217	"""Provide a list of pairs to delete from the blacklist"""
218
219	return rpc._rpc_blacklist_delete(pairs_to_delete)	1✔
220
221
222	@router.get('/whitelist', response_model=WhitelistResponse, tags=['info', 'pairlist'])	1✔
223	def whitelist(rpc: RPC = Depends(get_rpc)):	1✔
224	return rpc._rpc_whitelist()	1✔
225
226
227	@router.get('/locks', response_model=Locks, tags=['info', 'locks'])	1✔
228	def locks(rpc: RPC = Depends(get_rpc)):	1✔
229	return rpc._rpc_locks()	1✔
230
231
232	@router.delete('/locks/{lockid}', response_model=Locks, tags=['info', 'locks'])	1✔
233	def delete_lock(lockid: int, rpc: RPC = Depends(get_rpc)):	1✔
234	return rpc._rpc_delete_lock(lockid=lockid)	1✔
235
236
237	@router.post('/locks/delete', response_model=Locks, tags=['info', 'locks'])	1✔
238	def delete_lock_pair(payload: DeleteLockRequest, rpc: RPC = Depends(get_rpc)):	1✔
239	return rpc._rpc_delete_lock(lockid=payload.lockid, pair=payload.pair)	1✔
240
241
242	@router.get('/logs', response_model=Logs, tags=['info'])	1✔
243	def logs(limit: Optional[int] = None):	1✔
244	return RPC._rpc_get_logs(limit)	1✔
245
246
247	@router.post('/start', response_model=StatusMsg, tags=['botcontrol'])	1✔
248	def start(rpc: RPC = Depends(get_rpc)):	1✔
249	return rpc._rpc_start()	1✔
250
251
252	@router.post('/stop', response_model=StatusMsg, tags=['botcontrol'])	1✔
253	def stop(rpc: RPC = Depends(get_rpc)):	1✔
254	return rpc._rpc_stop()	1✔
255
256
257	@router.post('/stopentry', response_model=StatusMsg, tags=['botcontrol'])	1✔
258	@router.post('/stopbuy', response_model=StatusMsg, tags=['botcontrol'])	1✔
259	def stop_buy(rpc: RPC = Depends(get_rpc)):	1✔
260	return rpc._rpc_stopentry()	1✔
261
262
263	@router.post('/reload_config', response_model=StatusMsg, tags=['botcontrol'])	1✔
264	def reload_config(rpc: RPC = Depends(get_rpc)):	1✔
265	return rpc._rpc_reload_config()	1✔
266
267
268	@router.get('/pair_candles', response_model=PairHistory, tags=['candle data'])	1✔
269	def pair_candles(	1✔
270	pair: str, timeframe: str, limit: Optional[int] = None, rpc: RPC = Depends(get_rpc)):
271	return rpc._rpc_analysed_dataframe(pair, timeframe, limit)	1✔
272
273
274	@router.get('/pair_history', response_model=PairHistory, tags=['candle data'])	1✔
275	def pair_history(pair: str, timeframe: str, timerange: str, strategy: str,	1✔
276	freqaimodel: Optional[str] = None,
277	config=Depends(get_config), exchange=Depends(get_exchange)):
278	# The initial call to this endpoint can be slow, as it may need to initialize
279	# the exchange class.
280	config = deepcopy(config)	1✔
281	config.update({	1✔
282	'strategy': strategy,
283	'timerange': timerange,
284	'freqaimodel': freqaimodel if freqaimodel else config.get('freqaimodel'),
285	})
286	try:	1✔
287	return RPC._rpc_analysed_history_full(config, pair, timeframe, exchange)	1✔
288	except Exception as e:	1✔
289	raise HTTPException(status_code=502, detail=str(e))	1✔
290
291
292	@router.get('/plot_config', response_model=PlotConfig, tags=['candle data'])	1✔
293	def plot_config(strategy: Optional[str] = None, config=Depends(get_config),	1✔
294	rpc: Optional[RPC] = Depends(get_rpc_optional)):
295	if not strategy:	1✔
296	if not rpc:	1✔
297	raise RPCException("Strategy is mandatory in webserver mode.")	×
298	return PlotConfig.model_validate(rpc._rpc_plot_config())	1✔
299	else:
300	config1 = deepcopy(config)	1✔
301	config1.update({	1✔
302	'strategy': strategy
303	})
304	try:	1✔
305	return PlotConfig.model_validate(RPC._rpc_plot_config_with_strategy(config1))	1✔
306	except Exception as e:	1✔
307	raise HTTPException(status_code=502, detail=str(e))	1✔
308
309
310	@router.get('/strategies', response_model=StrategyListResponse, tags=['strategy'])	1✔
311	def list_strategies(config=Depends(get_config)):	1✔
312	from freqtrade.resolvers.strategy_resolver import StrategyResolver	1✔
313	strategies = StrategyResolver.search_all_objects(	1✔
314	config, False, config.get('recursive_strategy_search', False))
315	strategies = sorted(strategies, key=lambda x: x['name'])	1✔
316
317	return {'strategies': [x['name'] for x in strategies]}	1✔
318
319
320	@router.get('/strategy/{strategy}', response_model=StrategyResponse, tags=['strategy'])	1✔
321	def get_strategy(strategy: str, config=Depends(get_config)):	1✔
322	if ":" in strategy:	1✔
323	raise HTTPException(status_code=500, detail="base64 encoded strategies are not allowed.")	1✔
324
325	config_ = deepcopy(config)	1✔
326	from freqtrade.resolvers.strategy_resolver import StrategyResolver	1✔
327	try:	1✔
328	strategy_obj = StrategyResolver._load_strategy(strategy, config_,	1✔
329	extra_dir=config_.get('strategy_path'))
330	except OperationalException:	1✔
331	raise HTTPException(status_code=404, detail='Strategy not found')	1✔
332	except Exception as e:	×
333	raise HTTPException(status_code=502, detail=str(e))	×
334	return {	1✔
335	'strategy': strategy_obj.get_strategy_name(),
336	'code': strategy_obj.__source__,
337	}
338
339
340	@router.get('/exchanges', response_model=ExchangeListResponse, tags=[])	1✔
341	def list_exchanges(config=Depends(get_config)):	1✔
342	from freqtrade.exchange import list_available_exchanges	1✔
343	exchanges = list_available_exchanges(config)	1✔
344	return {	1✔
345	'exchanges': exchanges,
346	}
347
348
349	@router.get('/freqaimodels', response_model=FreqAIModelListResponse, tags=['freqai'])	1✔
350	def list_freqaimodels(config=Depends(get_config)):	1✔
351	from freqtrade.resolvers.freqaimodel_resolver import FreqaiModelResolver	1✔
352	models = FreqaiModelResolver.search_all_objects(	1✔
353	config, False)
354	models = sorted(models, key=lambda x: x['name'])	1✔
355
356	return {'freqaimodels': [x['name'] for x in models]}	1✔
357
358
359	@router.get('/available_pairs', response_model=AvailablePairs, tags=['candle data'])	1✔
360	def list_available_pairs(timeframe: Optional[str] = None, stake_currency: Optional[str] = None,	1✔
361	candletype: Optional[CandleType] = None, config=Depends(get_config)):
362
363	dh = get_datahandler(config['datadir'], config.get('dataformat_ohlcv'))	1✔
364	trading_mode: TradingMode = config.get('trading_mode', TradingMode.SPOT)	1✔
365	pair_interval = dh.ohlcv_get_available_data(config['datadir'], trading_mode)	1✔
366
367	if timeframe:	1✔
368	pair_interval = [pair for pair in pair_interval if pair[1] == timeframe]	1✔
369	if stake_currency:	1✔
370	pair_interval = [pair for pair in pair_interval if pair[0].endswith(stake_currency)]	1✔
371	if candletype:	1✔
372	pair_interval = [pair for pair in pair_interval if pair[2] == candletype]	1✔
373	else:
374	candle_type = CandleType.get_default(trading_mode)	1✔
375	pair_interval = [pair for pair in pair_interval if pair[2] == candle_type]	1✔
376
377	pair_interval = sorted(pair_interval, key=lambda x: x[0])	1✔
378
379	pairs = list({x[0] for x in pair_interval})	1✔
380	pairs.sort()	1✔
381	result = {	1✔
382	'length': len(pairs),
383	'pairs': pairs,
384	'pair_interval': pair_interval,
385	}
386	return result	1✔
387
388
389	@router.get('/sysinfo', response_model=SysInfo, tags=['info'])	1✔
390	def sysinfo():	1✔
391	return RPC._rpc_sysinfo()	1✔
392
393
394	@router.get('/health', response_model=Health, tags=['info'])	1✔
395	def health(rpc: RPC = Depends(get_rpc)):	1✔
396	return rpc.health()	1✔

freqtrade / freqtrade / 6181253459

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous