Bonjour j'ai un problème au niveau d'un même codes : -un code sur mon pc windows
                                                                                        -un code sur un serveur amazon (linux)




Version python 3.10.5 PC
Version python 3.10.4 Linux

Avant, le code sur linux marcher nickel à part ce matin le même code ne me donne pas la même valeur.




Le code <<len(ftx.get_open_position([symbol]))>> sur PC me donne 1 ou 0 mais sur linux me sort 8 (c'est le nombre de trades en cours.)




Le code me permet de connaître si une position est ouverte ou fermer 1 ou 0 mais sur linux il me donne le nombres totals de mes trades en cours alors que je souhaite juste une valeur.




En bref sur mon pc le code marche super bien, mais pas sur linux merci de votre aide

from instruction import cBot_perp_ftx
import ta
import pandas as pd
import numpy as np

ftx = cBot_perp_ftx(
        apiKey='',
secret='',
subAccountName=''
)

# -- Strategy variable --
perpSymbol = 'ETH-PERP','BTC-PERP','FTT-PERP','AVAX-PERP','BNB-PERP','ETC-PERP','ADA-PERP','MATIC-PERP','DOT-PERP','SOL-PERP'
leverage = 2

# -- Price Data --

class SuperTrend():
def __init__(
            self,
high,
low,
close,
atr_window=10,
atr_multi=3
):
        self.high = high
        self.low = low
        self.close = close
        self.atr_window = atr_window
        self.atr_multi = atr_multi
        self._run()

def _run(self):
# calculate ATR
price_diffs = [self.high - self.low,
self.high - self.close.shift(),
self.close.shift() - self.low]
        true_range = pd.concat(price_diffs, axis=1)
        true_range = true_range.abs().max(axis=1)
# default ATR calculation in supertrend indicator
atr = true_range.ewm(alpha=1 / self.atr_window, min_periods=self.atr_window).mean()
# atr = ta.volatility.average_true_range(high, low, close, atr_period)
 # df['atr'] = df['tr'].rolling(atr_period).mean()


 # HL2 is simply the average of high and low prices
hl2 = (self.high + self.low) / 2
# upperband and lowerband calculation
 # notice that final bands are set to be equal to the respective bands
final_upperband = upperband = hl2 + (self.atr_multi * atr)
        final_lowerband = lowerband = hl2 - (self.atr_multi * atr)

# initialize Supertrend column to True
supertrend = [True] * len(self.close)

for i in range(1, len(self.close)):
            curr, prev = i, i - 1

# if current close price crosses above upperband
if self.close[curr] > final_upperband[prev]:
                supertrend[curr] = True
# if current close price crosses below lowerband
elif self.close[curr] < final_lowerband[prev]:
                supertrend[curr] = False
# else, the trend continues
else:
                supertrend[curr] = supertrend[prev]

# adjustment to the final bands
if supertrend[curr] == True and final_lowerband[curr] < final_lowerband[prev]:
                    final_lowerband[curr] = final_lowerband[prev]
if supertrend[curr] == False and final_upperband[curr] > final_upperband[prev]:
                    final_upperband[curr] = final_upperband[prev]

# to remove bands according to the trend direction
if supertrend[curr] == True:
                final_upperband[curr] = np.nan
else:
                final_lowerband[curr] = np.nan

        self.st = pd.DataFrame({
'Supertrend': supertrend,
'Final Lowerband': final_lowerband,
'Final Upperband': final_upperband
        })

def super_trend_upper(self):
return self.st['Final Upperband']

def super_trend_lower(self):
return self.st['Final Lowerband']

def super_trend_direction(self):
return self.st['Supertrend']

def openShortCondition(row):
if (row['ema_short'] <= row['ema_long']) & (row['super_trend_direction'] == False):
return True
 else:
return False

def openLongCondition(row):
if (row['ema_short'] >= row['ema_long']) & (row['super_trend_direction'] == True):
return True
 else:
return False

def closeLongCondition(row):
if (row['ema_short'] <= row['ema_long']) | (row['super_trend_direction'] == False):
return True
 else:
return False

def closeShortCondition(row):
if (row['super_trend_direction'] == True):
return True
 else:
return False
for symbol in perpSymbol:

    df = ftx.get_last_historical(symbol, '1h', 1000)
    print(symbol)

    df.drop(columns=df.columns.difference(['open', 'high', 'low', 'close', 'volume']), inplace=True)
    super_trend = SuperTrend(
                    df['high'],
df['low'],
df['close'],

)

    df['super_trend_direction'] = super_trend.super_trend_direction()
    df['ema_short'] = ta.trend.ema_indicator(close=df['close'], window=10)
    df['ema_long'] = ta.trend.ema_indicator(close=df['close'], window=100)



# -- indicators --





 # -- Condition to open Market LONG --


 # -- Condition to open Market SHORT --


 # -- Get USD amount on Sub Account --
usdAmount = ftx.get_balance_of_one_coin('USD')
    salut = len(ftx.get_open_position([symbol]))
    usdAmount = usdAmount - 10
usdAmount = usdAmount * 0.1
tokenamount = ftx.get_balance_of_one_coin(symbol)
    print(tokenamount)
    print(usdAmount)
#print(ftx.get_open_position())
 # -- Get actual price --
actualPrice = df.iloc[-1]['close']
    print(len(ftx.get_open_position([symbol])))


# -- Check if you have no position running --
if len(ftx.get_open_position([symbol])) == 1:
# -- Check if you have to open a LONG --
 # -- Check if you have a LONG open --
if ftx.get_open_position([symbol])[0]['side'] == 'long':
# -- Check if you have to close your LONG --
if closeLongCondition(df.iloc[-2]):
                print(ftx.close_all_open_position([symbol]))
                ftx.close_all_open_position([symbol])
                ftx.cancel_all_open_order(symbol)
                print('Close my LONG position')
else:
                print("A LONG is running and I don't want to stop it")
# -- Check if you have a SHORT open --
elif ftx.get_open_position([symbol])[0]['side'] == 'short':
if closeShortCondition(df.iloc[-2]):

                print(ftx.close_all_open_position([symbol]))
                ftx.close_all_open_position([symbol])
                ftx.cancel_all_open_order(symbol)
                print('Close my SHORT position')
else:
                print("A SHORT is running and I don't want to stop it")


if len(ftx.get_open_position([symbol])) == 0:
if openLongCondition(df.iloc[-2]):
# -- Cancel all order (stop loss) --
ftx.cancel_all_open_order(symbol)
            print(ftx.cancel_all_open_order(symbol))
# -- Define the quantity max of token from your usd balance --
quantityMax = float(usdAmount)/actualPrice
# -- Create a market order Long --
shortOrder = ftx.place_market_order(
                symbol,
'buy',
quantityMax,
leverage
            )
            print("Open a market buy at", actualPrice)
# -- Create a market stop loss -3% --
 # stopLoss = ftx.place_market_stop_loss(
 # p,
 # 'buy',
 # quantityMax,
 # actualPrice + 0.03 * actualPrice,
 # leverage
 # )
 # print("Place a Stop Loss at", actualPrice + 0.03 * actualPrice)
elif openShortCondition(df.iloc[-2]):
# -- Cancel all order (stop loss) --
a=ftx.cancel_all_open_order(symbol)
            print(a)
# -- Define the quantity max of token from your usd balance --
quantityMax = float(usdAmount) / actualPrice
# -- Create a market order Long --
shortOrder = ftx.place_market_order(
                symbol,
'sell',
quantityMax,
leverage
            )
            print("Open a market SHORT at", actualPrice)

# -- Create a market stop loss -3% --
 # stopLoss = ftx.place_market_stop_loss(
 # p,
 # 'buy',
 # quantityMax,
 # actualPrice + 0.03 * actualPrice,
 # leverage
 # )
 # print("Place a Stop Loss at", actualPrice + 0.03 * actualPrice)


else:
            print("No opportunity to take")

import ccxt
import pandas as pd
import json
import time

class cBot_perp_ftx():
def __init__(self, apiKey=None, secret=None, subAccountName=None):
        ftxAuthObject = {
"apiKey": apiKey,
"secret": secret,
'headers': {
'FTX-SUBACCOUNT': subAccountName
            }
        }
if ftxAuthObject['secret'] == None:
            self._auth = False
self._session = ccxt.ftx()
else:
            self._auth = True
self._session = ccxt.ftx(ftxAuthObject)
        self._session.load_markets()

def authentication_required(fn):
"""Annotation for methods that require auth."""
def wrapped(self, *args, **kwargs):
if not self._auth:
                print("You must be authenticated to use this method", fn)
                exit()
else:
return fn(self, *args, **kwargs)
return wrapped

def get_historical_since(self, symbol, timeframe, startDate):
try:
            tempData = self._session.fetch_ohlcv(symbol, timeframe, int(
                time.time()*1000)-1209600000, limit=1000)
            dtemp = pd.DataFrame(tempData)
            timeInter = int(dtemp.iloc[-1][0] - dtemp.iloc[-2][0])
except:
return None

finished = False
start = False
allDf = []
        startDate = self._session.parse8601(startDate)
while(start == False):
try:
                tempData = self._session.fetch_ohlcv(
                    symbol, timeframe, startDate, limit=1000)
                dtemp = pd.DataFrame(tempData)
                timeInter = int(dtemp.iloc[-1][0] - dtemp.iloc[-2][0])
                nextTime = int(dtemp.iloc[-1][0] + timeInter)
                allDf.append(dtemp)
                start = True
 except:
                startDate = startDate + 1209600000*2

if dtemp.shape[0] < 1:
            finished = True
 while(finished == False):
try:
                tempData = self._session.fetch_ohlcv(
                    symbol, timeframe, nextTime, limit=1000)
                dtemp = pd.DataFrame(tempData)
                nextTime = int(dtemp.iloc[-1][0] + timeInter)
                allDf.append(dtemp)
if dtemp.shape[0] < 1:
                    finished = True
 except:
                finished = True
result = pd.concat(allDf, ignore_index=True, sort=False)
        result = result.rename(
            columns={0: 'timestamp', 1: 'open', 2: 'high', 3: 'low', 4: 'close', 5: 'volume'})
        result = result.set_index(result['timestamp'])
        result.index = pd.to_datetime(result.index, unit='ms')
del result['timestamp']
return result

def get_last_historical(self, symbol, timeframe, limit):
        result = pd.DataFrame(data=self._session.fetch_ohlcv(
            symbol, timeframe, None, limit=limit))
        result = result.rename(
            columns={0: 'timestamp', 1: 'open', 2: 'high', 3: 'low', 4: 'close', 5: 'volume'})
        result = result.set_index(result['timestamp'])
        result.index = pd.to_datetime(result.index, unit='ms')
del result['timestamp']
return result

def get_min_order_amount(self, symbol):
return self._session.markets_by_id[symbol]['limits']['amount']['min']

def convert_amount_to_precision(self, symbol, amount):
return self._session.amount_to_precision(symbol, amount)

def convert_price_to_precision(self, symbol, price):
return self._session.price_to_precision(symbol, price)

    @authentication_required
def get_all_balance(self):
try:
            allBalance = self._session.fetchBalance()
except BaseException as err:
raise TypeError("An error occured in get_all_balance", err)
return allBalance['total']

    @authentication_required
def get_balance_of_one_coin(self, coin):
try:
            allBalance = self._session.fetchBalance()
except BaseException as err:
raise TypeError("An error occured in get_balance_of_one_coin", err)
try:
return allBalance['total'][coin]
except:
return 0

@authentication_required
def place_market_order(self, symbol, side, amount, leverage=1):
try:
return self._session.createOrder(
                symbol,
'market',
side,
self.convert_amount_to_precision(symbol, amount * leverage),
 None
)
except BaseException as err:
raise TypeError("An error occured in place_market_order", err)

    @authentication_required
def place_reduce_market_order(self, symbol, side, amount, leverage=1):
        params = {
'reduceOnly':True
}
try:
return self._session.createOrder(
                symbol,
'market',
side,
self.convert_amount_to_precision(symbol, amount * leverage),
 None,
params
            )
except BaseException as err:
raise TypeError("An error occured in place_reduce_market_order", err)

    @authentication_required
def place_limit_order(self, symbol, side, amount, price, leverage=1):
try:
return self._session.createOrder(
                symbol,
'limit',
side,
self.convert_amount_to_precision(symbol, amount * leverage),
self.convert_price_to_precision(symbol, price)
                )
except BaseException as err:
raise TypeError("An error occured in place_limit_order", err)

    @authentication_required
def place_reduce_limit_order(self, symbol, side, amount, price, leverage=1):
        params = {
'reduceOnly':True
}
try:
return self._session.createOrder(
                symbol,
'limit',
side,
self.convert_amount_to_precision(symbol, amount * leverage),
self.convert_price_to_precision(symbol, price),
params
                )
except BaseException as err:
raise TypeError("An error occured in place_reduce_limit_order", err)

    @authentication_required
def place_market_stop_loss(self, symbol, side, amount, price, leverage=1):
        params = {
'stopPrice': self.convert_price_to_precision(symbol, price), # your stop price
'reduceOnly':True
}
try:
return self._session.createOrder(
                symbol,
'stop',
side,
self.convert_amount_to_precision(symbol, amount * leverage),
 None,
params
                )
except BaseException as err:
raise TypeError("An error occured in place_market_stop_loss", err)

    @authentication_required
def place_market_take_profit(self, symbol, side, amount, price, leverage=1):
        params = {
'stopPrice': self.convert_price_to_precision(symbol, price), # your stop price
'reduceOnly':True
}
try:
return self._session.createOrder(
                symbol,
'takeProfit',
side,
self.convert_amount_to_precision(symbol, amount * leverage),
 None,
params
                )
except BaseException as err:
raise TypeError("An error occured in place_market_take_profit", err)


    @authentication_required
def cancel_all_open_order(self, symbol):
try:
return self._session.cancel_all_orders(symbol)
except BaseException as err:
raise TypeError("An error occured in cancel_all_open_order", err)

    @authentication_required
def cancel_order_by_id(self, id):
try:
return self._session.cancel_order(id)
except BaseException as err:
raise TypeError("An error occured in cancel_order_by_id", err)

    @authentication_required
def get_open_order(self, symbol=None):
try:
return self._session.fetchOpenOrders(symbol, None, None)
except BaseException as err:
raise TypeError("An error occured in get_open_order", err)

    @authentication_required
def get_open_conditionnal_order(self, symbol=None):
        params = {
'type':'stop'
}
try:
return self._session.fetchOpenOrders(symbol,None,None,params)
except BaseException as err:
raise TypeError("An error occured in get_open_conditionnal_order", err)

    @authentication_required
def get_my_trades(self, symbol=None, since=None, limit=1):
try:
return self._session.fetch_my_trades(symbol, since, limit)
except BaseException as err:
raise TypeError("An error occured in get_my_trades", err)

    @authentication_required
def get_open_position(self,symbol=None):
try:
            positions = self._session.fetchPositions(symbol)
            truePositions = []
for position in positions:
if float(position['contracts']) > 0:
                    truePositions.append(position)
return truePositions
except BaseException as err:
raise TypeError("An error occured in get_open_position", err)

    @authentication_required
def close_all_open_position(self,symbol=None):
try:
            positions = self._session.fetchPositions(symbol)
for position in positions:
if position['side'] == 'long' and position['contracts'] > 0:
                    self.place_reduce_market_order(position['symbol'], 'sell', position['contracts'])
elif position['side'] == 'short' and position['contracts'] > 0:
                    self.place_reduce_market_order(position['symbol'], 'buy', position['contracts'])
return 'Close all positions done'
except BaseException as err:
raise TypeError("An error occured in close_all_open_position", err)

-
Edité par Mtbanban 5 août 2022 à 14:15:38

Bonjour,

Vérifiez avec des print en comparant sur Windows et Linux que la valeur de symbol est identique, puis si truePositions l'est aussi.

Si ce n'est pas le cas, c'est de ce côté qu'il faudra comprendre pourquoi ces valeurs diffèrent.

fred1599 a écrit:

Bonjour,

Vérifiez avec des print en comparant sur Windows et Linux que la valeur de symbol est identique, puis si truePositions l'est aussi.

Si ce n'est pas le cas, c'est de ce côté qu'il faudra comprendre pourquoi ces valeurs diffèrent.

Merci de m'avoir répondu !

j'ai regardé est, ce sont les valeurs de truePosition qui sont différentes, ce que je ne comprends pas, c'est que c'est exactement le même code donc trouver une erreur alors que l'un marche et pas l'autre ça me tord un peu l'esprit.

Si vous avez une solutions je suis preneur.

merci !

Votre problème peut se trouver possiblement sur cette ligne,

positions = self._session.fetchPositions(symbol)

si de Windows à Linux cette liste change, il faudra voir ce qui se passe plus précisément dans la méthode fetchPositions

fred1599 a écrit:

Votre problème peut se trouver possiblement sur cette ligne,

positions = self._session.fetchPositions(symbol)

si de Windows à Linux cette liste change, il faudra voir ce qui se passe plus précisément dans la méthode fetchPositions

c'est bien le problème en gros dans mon code sur le pc elle prend bien la position du token que je veux alors que sur linux elle prend tous les tokens qui possède une position alors que je veux juste un token.

Mais je ne comprends toujours pas pourquoi ce n'est pas pareil entre les deux réponses des deux codes ...

alors que quand je print(symbol) il me donne le bon token que je cherche

-
Edité par Mtbanban 5 août 2022 à 16:50:30

N'ayant pas accès à cette méthode, difficile d'aider plus. Si vous avez une documentation sur cette méthode, regardez à nouveau si elle n'est pas utilisable pour un seul OS particulier. Mais là, je suis coincé selon ce que vous m'avez donné comme information.

fred1599 a écrit:

N'ayant pas accès à cette méthode, difficile d'aider plus. Si vous avez une documentation sur cette méthode, regardez à nouveau si elle n'est pas utilisable pour un seul OS particulier. Mais là, je suis coincé selon ce que vous m'avez donné comme information.

la méthode sur mon pc renvoie la valeur du token par contre sur linux cela renvoie la valeur de tous les token et je ne comprends pas pourquoi cela change ... j'ai regardé sur google et aucune indication a ce niveau-là.  le pire c'est que cela marcher avant ....

Mtbanban a écrit:

la méthode sur mon pc renvoie la valeur du token par contre sur linux cela renvoie la valeur de tous les token et je ne comprends pas pourquoi cela change

Ce qui est sympa avec Python, c'est qu'on peut toujours regarder le source de la fonction pour voir ce qui est différent... et probablement conclure que ce n'est pas la même version de la bibliothèque (ou de ses dépendances) qui sont utilisées;

mps a écrit:

Mtbanban a écrit:

la méthode sur mon pc renvoie la valeur du token par contre sur linux cela renvoie la valeur de tous les token et je ne comprends pas pourquoi cela change

Ce qui est sympa avec Python, c'est qu'on peut toujours regarder le source de la fonction pour voir ce qui est différent... et probablement conclure que ce n'est pas la même version de la bibliothèque (ou de ses dépendances) qui sont utilisées;

Merci de votre réponse.

Je n'arrive pas à mettre la version python3.10.5 sur le serveur ubuntu ... Et aussi comment je fais pour voir les bibliothèques que j'ai installé niveau version ??

Merci 

Mtbanban a écrit:

Je n'arrive pas à mettre la version python3.10.5 sur le serveur ubuntu ... Et aussi comment je fais pour voir les bibliothèques que j'ai installé niveau version ??

Déjà commencez par comparer les codes...et ce n'est pas Python qui est en défaut.

Pour le reste, "voir" quelles sont les versions installées dépend de comment vous avez fait ça. Si c'est avec pip,  la commande list suffit. Avec d'autres gestionnaires de packages, il faut voir... mais si c'est vous qui avez installé ça, vous devriez l'avoir noté quelque part (car c'est important de le savoir quand on découvre des soucis).

mps a écrit:

Mtbanban a écrit:

Je n'arrive pas à mettre la version python3.10.5 sur le serveur ubuntu ... Et aussi comment je fais pour voir les bibliothèques que j'ai installé niveau version ??

Déjà commencez par comparer les codes...et ce n'est pas Python qui est en défaut.

Pour le reste, "voir" quelles sont les versions installées dépend de comment vous avez fait ça. Si c'est avec pip,  la commande list suffit. Avec d'autres gestionnaires de packages, il faut voir... mais si c'est vous qui avez installé ça, vous devriez l'avoir noté quelque part (car c'est important de le savoir quand on découvre des soucis).

J'ai regardé les versions est c'est la version de CCXT qui est différentes par rapport à celle sur ubuntu j'ai la dernière sur pc par contre j'ai essayer d'installer la dernière version sur ubuntu mais la version reste la meme c'est vraiment bizarre.

Concernant le code c'est exactement le même donc je pense que c'est la bibliothèque ccxt 

Mtbanban a écrit:

Concernant le code c'est exactement le même donc je pense que c'est la bibliothèque ccxt 

Je ne parle pas de votre code mais de celui de la (ou des) bibliothèques appelées.