a
a
Weather:
city not found
HomeBitcoindanpaquin / coinbasepro-python: le client Python non officiel pour l’API Coinbase Pro

danpaquin / coinbasepro-python: le client Python non officiel pour l’API Coinbase Pro

Le client Python pour l’API Coinbase Pro (anciennement GDAX)

Fourni sous licence MIT par Daniel Paquin.

Remarque: cette bibliothèque peut être légèrement endommagée ou défectueuse. Le code est publié sous la licence MIT – prenez le message suivant à cœur:

LE LOGICIEL EST FOURNI «EN L’ÉTAT» SANS GARANTIE D’AUCUNE SORTE, EXPRESSE OU IMPLICITE, Y COMPRIS, MAIS SANS S’Y LIMITER, LES GARANTIES DE QUALITÉ MARCHANDE, D’ADÉQUATION À UN USAGE PARTICULIER ET D’ABSENCE DE CONTREFAÇON. EN AUCUN CAS, LES AUTEURS OU LES TITULAIRES DES DROITS D’AUTEUR NE SERONT RESPONSABLES DE TOUTE RÉCLAMATION, DOMMAGE OU AUTRE RESPONSABILITÉ, QU’ELLE SOIT CONTRACTUELLE, ILLÉGALE OU AUTRE, DÉCOULANT DE OU EN RELATION AVEC LE LOGICIEL OU UTILISATION OU AUTRE TRAITEMENT DANS LE LOGICIEL.

Avantages

  • Un wrapper Python simple à utiliser pour les points de terminaison publics et authentifiés.
  • En environ 10 minutes, vous pourriez négocier par programme sur l’un des plus grands échanges Bitcoin de monde!
  • Ne vous inquiétez pas de la gestion des nuances de l’API avec des méthodes faciles à utiliser pour chaque point de terminaison d’API.
  • Obtenez un avantage sur le marché en vous mettant sous le capot de CB Pro pour savoir quoi et qui se cache derrière chaque tick.

En développement

  • Script de test
  • Fonctionnalité supplémentaire pour le registre des commandes en temps réel
  • Client API FIX Besoin d’aide

Commencer

Ce README est la documentation sur la syntaxe du client python présentée dans ce référentiel. Consultez les chaînes de documentation de la fonction pour obtenir des détails complets sur la syntaxe.
Cette API tente de présenter une interface propre à CB Pro, mais pour l’utiliser à son plein potentiel, vous devez vous familiariser avec la documentation officielle de CB Pro.

pip install cbpro
#or
pip install git+git://github.com/danpaquin/coinbasepro-python.git

Client public

Seuls quelques points de terminaison de l’API sont accessibles à tous. Les points de terminaison publics peuvent être atteints en utilisant PublicClient

import cbpro
public_client = cbpro.PublicClient()

Méthodes PublicClient

public_client.get_products()
# Get the order book at the default level.
public_client.get_product_order_book('BTC-USD')
# Get the order book at a specific level.
public_client.get_product_order_book('BTC-USD', level=1)
# Get the product ticker for a specific product.
public_client.get_product_ticker(product_id='ETH-USD')
# Get the product trades for a specific product.
# Returns a generator
public_client.get_product_trades(product_id='ETH-USD')
public_client.get_product_historic_rates('ETH-USD')
# To include other parameters, see function docstring:
public_client.get_product_historic_rates('ETH-USD', granularity=3000)
public_client.get_product_24hr_stats('ETH-USD')
public_client.get_currencies()

Client authentifié

Tous les points de terminaison d’API ne sont pas accessibles à tous. Ceux qui nécessitent une authentification utilisateur peuvent être atteints en utilisant AuthenticatedClient. Vous devez configurer l’accès à l’API dans les paramètres de votre compte. La AuthenticatedClient hérite de toutes les méthodes de PublicClient
class, vous n’aurez donc besoin d’en initialiser qu’un si vous prévoyez d’intégrer les deux dans votre script.

import cbpro
auth_client = cbpro.AuthenticatedClient(key, b64secret, passphrase)
# Use the sandbox API (requires a different set of API access credentials)
auth_client = cbpro.AuthenticatedClient(key, b64secret, passphrase,
                                  api_url="https://api-public.sandbox.pro.coinbase.com")

Disposition

Certains appels sont paginés, ce qui signifie que plusieurs appels doivent être effectués pour recevoir l’ensemble de données complet. L’API CB Pro Python fournit une abstraction pour les points de terminaison paginés sous la forme de générateurs qui fournissent une interface propre pour l’itération, mais peuvent effectuer plusieurs requêtes HTTP en arrière-plan. Les options de mise en page before, after, est limit ils peuvent être fournis comme arguments de mot-clé si vous le souhaitez, mais ne sont pas obligatoires pour les cas d’utilisation typiques.

fills_gen = auth_client.get_fills()
# Get all fills (will possibly make multiple HTTP requests)
all_fills = list(fills_gen)

Un cas d’utilisation des paramètres de pagination qui mérite d’être souligné est d’obtenir uniquement les nouvelles données de la requête précédente. Pour le cas de get_fills(), la
trade_id est le paramètre utilisé pour l’indexation. En passant par
before=some_trade_id, il remplit juste plus récent que ça trade_id sera retourné. Notez que lorsque vous utilisez before, un maximum de 100 articles seront retournés – il s’agit d’une limitation de CB Pro.

from itertools import islice
# Get 5 most recent fills
recent_fills = islice(auth_client.get_fills(), 5)
# Only fetch new fills since last call by utilizing `before` parameter.
new_fills = auth_client.get_fills(before=recent_fills[0]['trade_id'])

Méthodes AuthenticatedClient

auth_client.get_accounts()
auth_client.get_account("7d0f7d8e-dd34-4d9c-a846-06f431c381ba")
# Returns generator:
auth_client.get_account_history("7d0f7d8e-dd34-4d9c-a846-06f431c381ba")
# Returns generator:
auth_client.get_account_holds("7d0f7d8e-dd34-4d9c-a846-06f431c381ba")
# Buy 0.01 BTC @ 100 USD
auth_client.buy(price='100.00', #USD
               size='0.01', #BTC
               order_type='limit',
               product_id='BTC-USD')
# Sell 0.01 BTC @ 200 USD
auth_client.sell(price='200.00', #USD
                size='0.01', #BTC
                order_type='limit',
                product_id='BTC-USD')
# Limit order-specific method
auth_client.place_limit_order(product_id='BTC-USD', 
                              side='buy', 
                              price='200.00', 
                              size='0.01')
# Place a market order by specifying amount of USD to use. 
# Alternatively, `size` could be used to specify quantity in BTC amount.
auth_client.place_market_order(product_id='BTC-USD', 
                               side='buy', 
                               funds='100.00')
# Stop order. `funds` can be used instead of `size` here.
auth_client.place_stop_order(product_id='BTC-USD', 
                              stop_type='loss', 
                              price='200.00', 
                              size='0.01')
auth_client.cancel_order("d50ec984-77a8-460a-b958-66f114b0de9b")
auth_client.cancel_all(product_id='BTC-USD')
# Returns generator:
auth_client.get_orders()
auth_client.get_order("d50ec984-77a8-460a-b958-66f114b0de9b")
# All return generators
auth_client.get_fills()
# Get fills for a specific order
auth_client.get_fills(order_id="d50ec984-77a8-460a-b958-66f114b0de9b")
# Get fills for a specific product
auth_client.get_fills(product_id="ETH-BTC")
depositParams = {
        'amount': '25.00', # Currency determined by account specified
        'coinbase_account_id': '60680c98bfe96c2601f27e9c'
}
auth_client.deposit(depositParams)
# Withdraw from CB Pro into Coinbase Wallet
withdrawParams = {
        'amount': '1.00', # Currency determined by account specified
        'coinbase_account_id': '536a541fa9393bb3c7000023'
}
auth_client.withdraw(withdrawParams)

WebsocketClient

Si vous souhaitez recevoir des mises à jour du marché en temps réel, vous devez vous abonner au flux websocket.

Abonnez-vous à un seul produit

import cbpro

# Parameters are optional
wsClient = cbpro.WebsocketClient(url="wss://ws-feed.pro.coinbase.com",
                                products="BTC-USD",
                                channels=["ticker"])
# Do other stuff...
wsClient.close()

Abonnez-vous à plus de produits

import cbpro
# Parameters are optional
wsClient = cbpro.WebsocketClient(url="wss://ws-feed.pro.coinbase.com",
                                products=["BTC-USD", "ETH-USD"],
                                channels=["ticker"])
# Do other stuff...
wsClient.close()

WebsocketClient + Mongodb

La WebsocketClient prend désormais en charge la collecte de données via MongoDB. Étant donné une collection MongoDB, le WebsocketClient transmettra les résultats directement dans la collection de base de données.

# import PyMongo and connect to a local, running Mongo instance
from pymongo import MongoClient
import cbpro
mongo_client = MongoClient('mongodb://localhost:27017/')

# specify the database and collection
db = mongo_client.cryptocurrency_database
BTC_collection = db.BTC_collection

# instantiate a WebsocketClient instance, with a Mongo collection as a parameter
wsClient = cbpro.WebsocketClient(url="wss://ws-feed.pro.coinbase.com", products="BTC-USD",
    mongo_collection=BTC_collection, should_print=False)
wsClient.start()

Méthodes WebsocketClient

La WebsocketClient s’abonne à un thread séparé lors de l’initialisation. Il existe trois méthodes que vous pouvez remplacer (avant l’initialisation) afin qu’il puisse réagir aux données en continu. Le client actuel est un modèle utilisé à des fins d’illustration uniquement.

  • onOpen – appelé une fois, juste avant la connexion socket est établie, c’est ici que vous souhaitez ajouter les paramètres initiaux.
  • onMessage – appelé une fois pour chaque message qui arrive et accepte un argument contenant le message de type dict.
  • on_close – appelé une fois après la fermeture du websocket.
  • close – appelez cette méthode pour fermer la connexion websocket (ne pas remplacer).
import cbpro, time
class myWebsocketClient(cbpro.WebsocketClient):
    def on_open(self):
        self.url = "wss://ws-feed.pro.coinbase.com/"
        self.products = ["LTC-USD"]
        self.message_count = 0
        print("Lets count the messages!")
    def on_message(self, msg):
        self.message_count += 1
        if 'price' in msg and 'type' in msg:
            print ("Message type:", msg["type"],
                   "t@ {:.3f}".format(float(msg["price"])))
    def on_close(self):
        print("-- Goodbye! --")

wsClient = myWebsocketClient()
wsClient.start()
print(wsClient.url, wsClient.products)
while (wsClient.message_count < 500):
    print ("nmessage_count =", "{} n".format(wsClient.message_count))
    time.sleep(1)
wsClient.close()

Tester

Une suite de tests est en cours de développement. Les tests pour le client authentifié nécessitent un jeu d’informations d’identification d’API sandbox. Pour les fournir, renommez
api_config.json.example dans le dossier de test dans api_config.json et modifiez le fichier en conséquence. Pour exécuter les tests, démarrez dans le répertoire du projet et exécutez

python -m pytest

CommanderRéserver en temps réel

La OrderBook s’abonne à un websocket et conserve un enregistrement en temps réel du journal des commandes pour l’entrée product_id. Donnez votre avis sur les améliorations futures.

import cbpro, time
order_book = cbpro.OrderBook(product_id='BTC-USD')
order_book.start()
time.sleep(10)
order_book.close()

Tester

Les tests unitaires sont en cours de développement en utilisant le framework pytest. Les contributions sont les bienvenues!

Pour exécuter la suite de tests complète, dans le répertoire du projet, exécutez:

Journal des modifications

1.1.2 Version actuelle de PyPI

  • Projet de refactoring pour Coinbase Pro
  • Révision majeure de la gestion de la pagination

1.0

  • La première version qui n’est pas compatible avec les versions précédentes
  • Refactorisé pour suivre les normes PEP 8
  • Amélioration de la documentation

0,3

  • Ajout du dépôt et du retrait des crypto-monnaies et des LTC (non documentés).
  • Ajout du support pour le trading sur marge (non documenté).
  • Amélioration de la fonctionnalité WebsocketClient.
  • Lancement progressif de OrderBook (non documenté).
  • Réduction des bogues mineurs et améliorations de la syntaxe.

0.2.2

  • Ajout de fonctionnalités API supplémentaires telles que cancelAll () et le retrait ETH.

0.2.1

  • Autorisation WebsocketClient pour fonctionner de manière intuitive et un flux de travail d’échantillons restructuré.

0,2,0

  • Projet renommé GDAX-Python
  • Mises à jour Websocket fusionnées pour gérer les erreurs et se reconnecter.

0.1.2

  • Gestion JSON mise à jour pour une plus grande compatibilité entre certains utilisateurs.
  • Ajout de la prise en charge des méthodes de paiement, des rapports et des comptes d’utilisateurs Coinbase.
  • Autres mises à jour de compatibilité.

0.1.1b2

https://github.com/danpaquin/coinbasepro-python

No comments

leave a comment