Community

Antworten
Highlighted
HimbeerToni
Aufsteiger
Beiträge: 3
Registriert: 20.03.2020
Nachricht 1 von 1 (146 Ansichten)

Trading API mit Python für Einsteiger

Wer mit der Programmiersprache Python die Consors Trading API nutzen will und sich auskennt, der wird hier fündig:
https://wissen.consorsbank.de/t5/Trading-API-ActiveTrader/Welche-Sprachen-verwendet-ihr/gpm-p/90644#... 
Wer damit allerdings nicht klarkommt, der könnte es mal mit dieser Beschreibung probieren:

Ich habe das auf einem Linux Rechner gemacht, aber vermutlich ist es in Windows nicht wesentlich anders.

Dies ist eine Beschreibung für "nicht- Informatiker", Anfänger und "Hobby- Möchtegern- Programmierer" (so wie ich einer bin).
Sie erklärt nicht wieso und warum. Sie könnte aber jemandem helfen nicht zu früh und frustriert aufzugeben.
Darum poste ich's.

Ich nutze Python 3.6 mit Pycharm als Editor (Gibt´s für Linux, Mac und Windows).
Pycharm nutzt eine virtuelle Umgebung für Projekte - Wenn ich im folgenden also "venv" schreibe, dann meine ich die virtuelle Umgebung von Pycharm.
Wer einen anderen Editor benutzt, ohne eine venv, der muss sein Vorgehen entsprechend anpassen. . .

Als Ausgangspunkt nutze ich ein Code- Beispiel für die Trading-API in Python, das die Account-Daten abruft.
Ich habe es von hier "geklaut".
Damit Ihr nicht hin und herspringen müsst, ist es hier nochmal, ganz leicht verändert, mit ein paar kleinen Hinweisen:

# Copyright 2018 Consorsbank and gRPC authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""The Python implementation of the GRPC client."""

from __future__ import print_function

import grpc

import AccessService_pb2
import AccessService_pb2_grpc
import AccountService_pb2
import AccountService_pb2_grpc
import Common_pb2
import Common_pb2_grpc
import DepotService_pb2
import DepotService_pb2_grpc
import OrderService_pb2
import OrderService_pb2_grpc
import SecurityService_pb2
import SecurityService_pb2_grpc
import StockExchangeService_pb2
import StockExchangeService_pb2_grpc
import TradingTypes_pb2
import TradingTypes_pb2_grpc
import TradingAPI_pb2
import TradingAPI_pb2_grpc

def run():

host = "localhost"
port = 40443

with open('DeinPfadZurDatei/roots.pem', 'rb') as f:
trusted_certs = f.read()

credentials = grpc.ssl_channel_credentials(root_certificates=trusted_certs)
channel = grpc.secure_channel('{}:{}'.format(host, port), credentials)

access_service_stub = TradingAPI_pb2_grpc.AccessServiceStub(channel)
login_response = access_service_stub.Login(AccessService_pb2.LoginRequest(secret='DeinSecret'))

print("Login response: " + str(login_response))

account_service_stub = TradingAPI_pb2_grpc.AccountServiceStub(channel)
accounts_response = account_service_stub.GetTradingAccounts(Common_pb2.AccessTokenRequest(access_token=login_response.access_token))

print("Accounts response: " + str(accounts_response))


if __name__ == '__main__':
run()

 

Das kleine Progrämmchen läuft allerdings erst nach einigen Vorbereitungen:

Zunächst muss grpcio und grpcio-tools im venv von Pycharm installiert werden.
(Wer das ohne Pycharm oder ohne venv macht, muss es eben im System installieren - pip install grpcio und pip install grpcio-tools sollte helfen. . . )
Das geht in Pycharm über's Menü:
File/Settings dort im Projekt, findet sich die Package Liste des Projekt- Interpreters.
In der Package Liste gibt es pip - auf dieses doppelklicken.
In der Suchfunktion nach grpcio suchen und installieren. Gleiches mit grpcio-tools.
Wenn ich mich richtig erinnere, war dann automatisch auch protobuf installiert, ohne dass ich da noch was machen musste.
Falls ich mich falsch erinnere, müsst Ihr das auch noch suchen und installieren. Sollte in der Liste sein . . .

Nun solltet Ihr, falls noch nicht geschehen, die TAPI von Consors runterladen.
Es wird zwar "Download API Dokumentationen und Beispiele" genannt, aber da ist auch der Code drin, der gebraucht wird.
Die Dokumentation gibt es nur für C# und Java.
Ich hab' Java genutzt.
Das File entpacken und in ein Verzeichnis im venv von Pycharm kopieren, oder wo Ihr sonst Euer Projekt liegen habt. . .
Bei mir war das nun also in venv/TapiJava

Nun müssen sogenannte "Protobuf-Files" erstellt werden:
Das geht mit folgendem Befehl, den man im Terminal von Pycharm eingibt (eins der Register ganz unten. . . oder eben im Terminal vom System - müsste egal sein):
(Ihr solltet Euch in venv/TapiJava befinden und hier gibt es einen Unterordner proto)

python -m grpc_tools.protoc -Iproto --python_out=. --grpc_python_out=. AccessService.proto

Das erzeugt 2 Dateien im Verzeichnis TapiJava namens: AccessService_pb2.py und AccessService_pb2_grpc.py
Diese 2 Dateien müssen in ein Verzeichnis, dass Python beim Start Eures Programms später auch durchsucht.
Welche das bei Euch sind, könnt Ihr mit dem Befehl: "python -m site" ermitteln.
Ich hab' mich für /venv/lib/python3.6/site-packages/ entschieden.

Das muss nun mit allen Dateien im Ordner proto gemacht werden.
Also im Terminal:
python -m grpc_tools.protoc -Iproto --python_out=. --grpc_python_out=. AccountService.proto
python -m grpc_tools.protoc -Iproto --python_out=. --grpc_python_out=. Common.proto
python -m grpc_tools.protoc -Iproto --python_out=. --grpc_python_out=. DepotService.proto
python -m grpc_tools.protoc -Iproto --python_out=. --grpc_python_out=. OrderService.proto
python -m grpc_tools.protoc -Iproto --python_out=. --grpc_python_out=. SecurityService.proto
python -m grpc_tools.protoc -Iproto --python_out=. --grpc_python_out=. StockExchangeService.proto
python -m grpc_tools.protoc -Iproto --python_out=. --grpc_python_out=. TradingAPI.proto
python -m grpc_tools.protoc -Iproto --python_out=. --grpc_python_out=. TradingTypes.proto

 

Alle so erstellten Dateien (jeweils 2, eine mit *_pb2.py und eine mit *_pb2_grpc) nach /venv/lib/python3.6/site-packages/ kopieren.
(Oder in das für Euch passende Verzeichnis)

 

Das war's noch nicht ganz:

Die Datei roots.pem muss mit Hilfe des Active Traders erzeugt werden.
Ach ja, die Trading API funktioniert nur, wenn auch der Active Trader läuft. . .

Bei mir (im Linux System) läuft er unter WINE. (Nicht ganz fehlerfrei, aber für unsere Zwecke reicht's. . . )

Im Active Trader im Menü unter: Active Trader/Konfiguration öffnen / Globale Einstellungen/Trading API
Häckchen bei "Trading API aktiv" setzen.
Einen Key generieren.
Ein Secret aussuchen - merken. . .
Und EXPORT TRUST CERTIFICATE auswählen. Das erzeugt die roots.pem Datei, die Ihr speichern müsst - wo?
Ich hab' es hier rein:
/venv/lib/python3.6/site-packages/grpc/_cython/_credentials/
Das war auch die ursprünglich vorgesehene Stelle im obigen Code.
Ihr könnt sie vermutlich auch sonst wo hin kopieren, nur daran denken, dass Ihr im Code "DeinPfadZurDatei" entsprechend anpasst.

Nun noch das Secret, das Ihr Euch gemerkt habt in den Code statt "DeinSecret" eingeben.

Wenn ich nix wesentliches vergessen habe, sollte der Beispielcode jetzt laufen und Eure Kontodaten ausspucken.
Aber nur solange der Active Trader läuft und Ihr angemeldet seid.

Jetzt kann der eigentliche Programmierspaß beginnen. . .