Partage
  • Partager sur Facebook
  • Partager sur Twitter

Différentes valeurs code PC code sur amazon

    5 août 2022 à 12:36:22

    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

    • Partager sur Facebook
    • Partager sur Twitter
      5 août 2022 à 14:38:30

      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.

      • Partager sur Facebook
      • Partager sur Twitter

      Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
      La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

        5 août 2022 à 15:02:01

        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 !

        • Partager sur Facebook
        • Partager sur Twitter
          5 août 2022 à 16:25:48

          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



          • Partager sur Facebook
          • Partager sur Twitter

          Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
          La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

            5 août 2022 à 16:48:12

            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

            • Partager sur Facebook
            • Partager sur Twitter
              5 août 2022 à 17:02:34

              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.
              • Partager sur Facebook
              • Partager sur Twitter

              Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
              La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

                5 août 2022 à 17:59:01

                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 ....
                • Partager sur Facebook
                • Partager sur Twitter
                  5 août 2022 à 19:00:06

                  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;
                  • Partager sur Facebook
                  • Partager sur Twitter
                    5 août 2022 à 20:12:27

                    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 

                    • Partager sur Facebook
                    • Partager sur Twitter
                      5 août 2022 à 22:15:48

                      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).

                      • Partager sur Facebook
                      • Partager sur Twitter
                        5 août 2022 à 23:14:49

                        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 

                        • Partager sur Facebook
                        • Partager sur Twitter
                          6 août 2022 à 8:28:37

                          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.
                          • Partager sur Facebook
                          • Partager sur Twitter

                          Différentes valeurs code PC code sur amazon

                          × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                          • Editeur
                          • Markdown