ProRealTime
Forum dédié à ProRealTime cfds à risque limité : les questions sur les cfds à risque limité à risque limité, les trucs et astuces sur l'interface de trading...
Répondre • Page 1 sur 1

Bouton PRT stop a 0

par Devix » 31 juil. 2020 15:54

Bonjour,

J'utilise l'interface de scalping avec les gros boutons sur prt pour passer mes trades.
J'utilise le bouton "Stop a 0 ticks" qui permet de placer le stop a 0.
Le seul truc c'est qu'il faut retirer l'ancien stop pour le placer a 0. Du coup ça fait perdre un peut de temps.
Je me demandais si il y a un bouton quelque part dans prt pour supprimer l'ancien stop et mettre le nouveau a 0, voir encore mieux a +1.
Savez-vous si cela existe ?

Merci d'avance.

Re: Bouton PRT stop a 0

par Francis1 » 12 août 2020 22:55

No

Re: Bouton PRT stop a 0

par DarkPoule » 13 août 2020 13:39

non ça n'existe pas. en revanche tu peux utiliser des raccourcis clavier. donc enchaîner sans déplacer la souris.
Et mieux encore, si tu as un clavier gamer, tu peux programmer des macros qui enchaîne deux touches avec 0.5s entre deux.

Apres pour ma part j'ai un robot qui fait ce boulot a ma place (en python). dés que j'atteint +6 sur dax, mon robot me place un SL+1 automatiquement, mais la il faut quelques connaissance en programmation.

je crois voir que tu as des connaissances en Java, linux etc...
Donc tu as la possibilité de faire ça, ig possède des API.
https://labs.ig.com/rest-trading-api-guide

Si tu veux un exemple python dis le moi.

Je pense que tu trouveras ton bonheur avec les API.

Re: Bouton PRT stop a 0

par Devix » 17 août 2020 11:24

Désolé j'avais pas vu que j'avais eu des retours :S
Oui en effet je suis développeur.

Tu as un repo github avec tes exemples ? ça serait super utile :)

Re: Bouton PRT stop a 0

par DarkPoule » 17 août 2020 11:40

j'ai des repo, mais privé ;)
déjà j'utilise un wrapper > https://github.com/ig-python/ig-markets-api-python-library
ça permet de pas se farcir toute les requêtes.

Donc il y a deux API :
Les API stream
Les API rest

Avec les stream, tu peux suivre les cours en temps en réel, en tick en minutes etc ...
Avec les api rest, tu peux creer, modifier, supprimer des ordres etc ...

Je vais t'envoyer le code python d'un script qui :
Se connecte au Dax et au Dow Jones en stream.
Dés que je prend une positions, il l'a protege avec un SL+1

Donc... pour dax, le stop mini est a 5pts. Donc pour protéger a SL0, il faut que tu sois a +5pts de gain
Pour proteger a SL+1.... il faut donc être a +6pts de gain. Tu vois ?

Attention, mon code ne gère que la dernière position prise (pas de multiples positions)

Une fois que le SL est posé... tu le gère a la main.

Je l'ai Fichu sur une machine OVH a 3€/mois, pour ne pas sollicité mon proc et ma connexion.
En plus sur ovh j'ai un ping de 3ms, donc pour placer le SL c'est trés rapide. un bref passage a +6 et hop le SL est déja la.

Re: Bouton PRT stop a 0

par DarkPoule » 17 août 2020 11:46

Spoiler:

Code : #

#!/usr/bin/env python
#-*- coding:utf-8 -*-
import sys
sys.path.insert(0,'/home/ubuntu')
print(sys.path)

from tradingbox.trading_ig_config import config as config
from tradingbox.trading_ig_config import config_interface
from trading_ig import IGService, IGStreamService
from trading_ig.lightstreamer import Subscription
from threading import Thread
import json
import requests

class Stop(Thread):
    def __init__(self):
        Thread.__init__(self)

    def launch_stop(self, params):
        stop = ac.ig_service.update_open_position(limit_level=None,
                                                  stop_level=params['stop_level'],
                                                  deal_id=params['deal_id'],)

class Account_connection(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.ig_service = IGService(username=config.username,
                                    password=config.password,
                                    api_key=config.api_key,
                                    acc_type=config.acc_type)
        print("Account_connection:", config.username, config.acc_type)
        self.ig_service.create_session()
        self.protection = False

        self.epic_params = {
            dax : dax_ballot.mini_distance_stop,
            dow : dow_ballot.mini_distance_stop,
        }
        self.levels_protections = {}

    def stream_init(self):
        ig_service = IGService(config.username, config.password, config.api_key, config.acc_type)
        self.ig_stream_service = IGStreamService(ig_service)
        ig_session = self.ig_stream_service.create_session()
        accounts = ig_session[u'accounts']
        for account in accounts:
            if account[u'accountId'] == config.acc_number:
                self.accountId = account[u'accountId']
            else:
                print('Account not found: {0}'.format(config.acc_number))
                self.accountId = None
        self.ig_stream_service.connect(self.accountId)

    def run(self):
        self.stream_init()
        account_str = 'TRADE:{}'.format(config.acc_number)
        self.subcription_trades = Subscription(
            mode="DISTINCT",
            items=[account_str],
            fields=["CONFIRMS","OPU","WOU"],)
        self.subcription_trades.addlistener(self.on_account_update)
        sub_key_trades = self.ig_stream_service.ls_client.subscribe(self.subcription_trades)
        input("{0:-^80}\n".format("HIT CR TO UNSUBSCRIBE AND DISCONNECT FROM LIGHTSTREAMER"))
        self.ig_stream_service.disconnect()

    def get_account_balance(self):
        self.ig_service.create_session()
        balance = self.ig_service.ig_session['accountInfo']['balance']
        # account_detail = self.ig_service.fetch_accounts()
        # balance = account_detail['accounts'][0]['balance']['balance']
        # if account_detail['accounts'][0]['currency'] == 'EUR':
        #     currency = '€'
        # else:
        #     currency = '€'
        currency = '€'
        return balance, currency


    def get_epic_value(self, epic):
        res = self.ig_service.fetch_market_by_epic(epic)
        if res['instrument']['marketId'] == 'DE30':
            n = 'DAX'
        else:
            n = 'DOW'
        if res['instrument']['currencies'][0]['name'] == 'EUR':
            c = "€"
        else:
            c = res['instrument']['currencies'][0]['name']

        return  {'high' : res['snapshot']['high'],
                 'minDealSize' : res['dealingRules']['minDealSize']['value'],
                 'name': n,
                 'currency': c}

    def position_epic_button(self, epic):
        return self.get_epic_value(epic)

    def update_account_raspi(self, epic=False):
        balance, currency = self.get_account_balance()
        epic_value = self.position_epic_button(epic) #TODO depend position of GPIO raspi
        pos_size = round((balance / (epic_value['high'] * (1 + (config_interface.marge_max_epic/100)))) * config_interface.levier,2)
        res = {
            'balance': balance,
            'pos_size': pos_size,
        }
        datas = {"datas_new_account": "update"}
        datas.update(res)
        requests.get(
            "{}/api/v1/receveid_information/account_balance".format(config_interface.ip_raspi), params=datas)
        return res

    def update_protection_list(self, epic, deal_id):
        if self.levels_protections != {}:
            protections = self.levels_protections[epic]
            if deal_id in protections['deal_id']:
                # self.levels_protections[epic] =  {}
                self.levels_protections = {}
        return False

    def on_account_update(self, item_update):
        print("on_account_update:", item_update)

        if item_update['pos']:
            try:
                js = json.loads(item_update['values']['CONFIRMS'])
            except:
                js = json.loads(item_update['values']['OPU'])
            if js['dealStatus'] == 'ACCEPTED' and js['status'] == 'OPEN' and js['epic'] in self.epic_params:
                level = js['level']
                epic = js['epic']
                direction = js['direction']
                deal_id = js['dealId']

                if direction == 'BUY':
                    real_stop_level = level + self.epic_params[epic] + 1
                    real_stop_level_distance = level + 1
                    self.levels_protections[epic] = {
                        'direction': 'BUY',
                        'level': level,
                        'real_stop_level': real_stop_level,
                        'real_stop_level_distance':real_stop_level_distance,
                        'deal_id':deal_id,}
                else:
                    real_stop_level = level - self.epic_params[epic] - 1
                    real_stop_level_distance = level - 1
                    self.levels_protections[epic] = {
                        'direction': 'SELL',
                        'level': level,
                        'real_stop_level': real_stop_level,
                        'real_stop_level_distance':real_stop_level_distance,
                        'deal_id':deal_id,}

            # LA PARTIE UPDATE DE RAPSPI interface account_balance + size_position.
            elif js['dealStatus'] == 'ACCEPTED' and js['status'] in ['AMENDED','DELETED']:
                deal_id = js['dealId']
                epic = js['epic']
                self.update_protection_list(epic, deal_id)

                res = self.update_account_raspi(epic)
                print()
                print(res)
                print()



class Epic_Connection(Thread):
    def __init__(self, epic):
        Thread.__init__(self)
        self.price = dict()
        self.epic = epic
        self.deal_ids = []
        self.ig_service = IGService(username=config.username,
                                    password=config.password,
                                    api_key=config.api_key,
                                    acc_type=config.acc_type)
        self.ig_service.create_session()
        self.mini_distance_stop = self.get_info_on_epic(epic)
        print(epic, self.get_info_on_epic(epic))
        self.stop = Stop()
        print("Epic_Connection:", config.username, config.acc_type, epic)

    def stream_init(self):
        ig_service = IGService(config.username, config.password, config.api_key, config.acc_type)
        self.ig_stream_service = IGStreamService(ig_service)
        ig_session = self.ig_stream_service.create_session()
        accounts = ig_session[u'accounts']
        for account in accounts:
            if account[u'accountId'] == config.acc_number:
                self.accountId = account[u'accountId']
            else:
                print('Account not found: {0}'.format(config.acc_number))
                self.accountId = None
        self.ig_stream_service.connect(self.accountId)

    def run(self):
        self.stream_init()
        self.subcription_trades = Subscription(
            mode="MERGE",
            items=["MARKET:" + self.epic],
            fields=["BID", "OFFER"],)
        self.subcription_trades.addlistener(self.on_epic_update)
        sub_key_trades = self.ig_stream_service.ls_client.subscribe(self.subcription_trades)
        input("{0:-^80}\n".format("HIT CR TO UNSUBSCRIBE AND DISCONNECT FROM LIGHTSTREAMER"))
        self.ig_stream_service.disconnect()

    def on_epic_update(self, item_update):
        # ON verifie l epic
        print("on_epic_update:", item_update)
        print("-->", ac.levels_protections)
        market = item_update['name'].replace('MARKET:','')
        buy_price = float(item_update['values']['BID'])
        sell_price = float(item_update['values']['OFFER'])

        if market in ac.levels_protections:
            real_stop_level = ac.levels_protections[market]['real_stop_level'] # level d'execution du SL+1 (+5 sur dax)
            real_stop_level_distance = ac.levels_protections[market]['real_stop_level_distance'] # level SL+1
            deal_id = ac.levels_protections[market]['deal_id']

            if buy_price >= real_stop_level and ac.levels_protections[market]['direction'] == 'BUY':
                print("!! on met un vrai stop BUY !!")
                params = {'deal_id': deal_id,
                          'stop_level': real_stop_level_distance}
                self.stop.launch_stop(params=params)
                ac.levels_protections.pop(market, False)

            elif sell_price <= real_stop_level and ac.levels_protections[market]['direction'] == 'SELL':
                print("!! on met un vrai stop SELL !!")
                params = {'deal_id': deal_id,
                          'stop_level': real_stop_level_distance}
                self.stop.launch_stop(params=params)
                ac.levels_protections.pop(market, False)

    def get_info_on_epic(self, epic):
        epic_info = self.ig_service.fetch_market_by_epic(epic)
        mini_distance_stop = epic_info['dealingRules']['minNormalStopOrLimitDistance']['value']
        return mini_distance_stop

dax = "IX.D.DAX.IFMM.IP"
dow = "IX.D.DOW.IFE.IP"

dax_ballot = Epic_Connection(dax)
dow_ballot = Epic_Connection(dow)
ac = Account_connection()

dax_ballot.start()
dow_ballot.start()
ac.start()


il faut que tu creer un fichier .py nommé trading_ig_config.py
dedans il faut y retrouvé les éléments de connexion confiendentiel

class config(object):
username = "xxx"
password = "xxx"
api_key = "zzzzzzzzzzzzzzzzz"
acc_type = "DEMO" # LIVE / DEMO
acc_number = "ZZZZZ"
levier = 1
marge_max_epic = 5

Les requirements:
certifi==2020.6.20
chardet==3.0.4
idna==2.10
requests==2.24.0
six==1.15.0
urllib3==1.25.9

----------------------
un peu en dehors de ça, j'avais fait une form.
Ou je peux gérer les SL+x.
Et la ça en prend plusieurs.
PROTECT XX permet de balancer le SL+1 si les conditions sont réuni...
Et ensuite je le monte de +1 +2 ou +5... s'il continu de monter.
C'est utile dans les pyramidage... quand j'ai 5 ou 6 positions a monté en meme temps.
Capture d’écran du 2020-08-17 11-47-47.png
Voila je pense que tu as déja de quoi faire :)
Seuls les membres inscrits peuvent voir les fichiers.
L'inscription au forum prend moins de 30 secondes.

Re: Bouton PRT stop a 0

par Devix » 18 août 2020 08:54

merci beaucoup ! Je vais regarder ça attentivement :) Oui en effet j'ai de quoi faire. Il y pas mal de petits tools comme ça qui pourrait être super utile :)

Sujets similaires
PRT : Comment régler le bouton "Gestion de capital"
par Jim » 18 juin 2013 14:36 (3 Réponses)
PureDeal > Comment mettre le bouton "Compte" à gauche
par Eversa » 27 nov. 2013 11:59 (4 Réponses)
Bug sur bouton "Mes messages"
par kero » 18 nov. 2017 18:10 (10 Réponses)
Ajouter un bouton recherche
par Eversa » 08 mai 2018 23:45 (4 Réponses)
Stop Suiveur PRT vs. Stop Suiveur fait maison
par Anonymous99 » 11 juil. 2014 10:44 (27 Réponses)
PRT cfd à risque limité trailing stop et stop garanti
par Alex44 » 27 avr. 2017 20:56 (17 Réponses)
Stop et Stop garantis avec PRT/IG
par Mr PSYKO » 02 oct. 2018 09:24 (27 Réponses)
Stop vs. stop garanti
par sepaki » 22 déc. 2012 17:40 (9 Réponses)
Stop Suiveur (Trailing Stop)
par Ernesto » 10 sept. 2013 13:20 (8 Réponses)