[First Ripple] [I am] Appeler JavaScript (Node.js) depuis Python et traiter Ripple
introduction
Récemment, les personnes dites Fintech sont souvent devenues des adeptes sur Twitter.
Quand je regarde les tweets, il y a pas mal d'histoires sur Ripple. Il y a beaucoup de discussions à propos de Mizuho Bank, alors je me demandais si moi, qui suis un Hijikata numérique (je ne le connais pas récemment), je n'avais rien à voir avec cela.
Cependant, quand je regarde le site Developper, cela peut être naturel de nos jours, mais c'est un produit open source, et j'ai pu abandonner le système d'API gratuitement. Il semble que vous puissiez accéder au réseau Ripple en production en utilisant l'API fournie par Node.js.
Je suis un programmeur triste qui a récemment ruiné tous les langages, mais parmi eux, Python est raisonnablement bien utilisé. De plus, avec Python, les systèmes d'apprentissage automatique et les systèmes de calcul sont également importants.J'ai donc pensé qu'il serait assez amusant d'utiliser des contrats automatiques d'IA utilisant Ripple. Cette fois, la partie de base de l'appel de JavaScript à partir de Python pour accéder à l'API Ripple est terminée, je vais donc la publier avec la signification d'un rappel.
Donc que fais-tu
Je suis désolé que le prototype cette fois ne soit pas très significatif en tant que fonction. C'est comme ça.
- Principalement Python
- Obtenez le paramètre totalDrops du réseau RIpple (probablement l'un des mouvements XRP?) Périodiquement pendant un certain temps.
- Combinez ces données en données csv.
- Rendons les données csv résumées disponibles dans R.
- Utilisez JavaScript en utilisant Node.js uniquement lorsque les paramètres sont pris.
Sur la base de ce livrable, je pense qu'il sera possible d'augmenter la production d'appels RippleAPI et de les connecter avec TensorFlow.
Qu'est-ce que Ripple
C'est un protocole de paiement qui applique la blockchain. Eh bien, je pense que ce sera une technologie à la mode. Le chef de famille est ici.
En ce qui concerne l'explication de Ripple, le site suivant de Giant Gox est très bien organisé. http://gtgox.com/
Je pense que vous pouvez comprendre le plan si vous regardez "Qu'est-ce que Ripple" dans ↑.
Qu'est-ce que l'API Ripple?
Le site du développeur est ici. Vous en trouverez ci-dessous une citation.
Le réseau de paiement décentralisé de _Ripple repose sur une technologie open source accessible à tous. Voici les outils disponibles pour les développeurs pour créer des solutions sur des plateformes open source. _
L'API Ripple semble être l'un des "outils disponibles" mentionnés ci-dessus, et il semble que vous puissiez accéder au serveur Ripple avec JavaScript et transférer de l'argent.
L'API Ripple s'exécute sur node_js et utilise ECMAScript 6 (ES2015). En d'autres termes, il semble que vous puissiez accéder au système en l'exécutant à l'aide de babel-node.
Consultez le site suivant pour les spécifications de l'API. https://ripple.com/build/rippleapi/
Le script est écrit comme ceci ici. https://ripple.com/build/rippleapi/#boilerplate
Cette fois, selon la ↑, nous utiliserons l'API appelée getLedger pour obtenir les données appelées totalDrops. La description de l'API est ici. https://ripple.com/build/rippleapi/#getledger
Construction de l'environnement d'exécution
Il existe un Guide du débutant pour Ripple, c'est donc une bonne idée de le regarder. Voici quelques suppléments.
Comme je l'ai écrit dans l'explication de l'API, vous avez besoin d'un environnement dans lequel node_js peut être exécuté. Je pense qu'il y a beaucoup d'informations sur la configuration de node_js, donc je vais l'omettre. Lorsque vous utilisez l'API Ripple, la version 0.12, 4.x ou supérieure est requise au moment de la rédaction (août 2016), veuillez donc créer un tel environnement.
Je l'ai construit sur MacOSX node_js 0.12.4.
Si vous faites fonctionner node_js, il semble que vous serez prêt si vous mettez babel dans la procédure suivante (il s'agit d'une vente de Guide du débutant)
- Créez un dossier approprié et déplacez-le.
- git init si nécessaire (je ne l'ai pas fait).
- Écrivez package.json ici. Le contenu peut être trouvé dans le Guide du débutant, vous pouvez donc le copier et le coller.
- Si vous faites
`npm install`, babel etc. entrera. - Comme vous pouvez le voir dans le guide, un avertissement apparaît au moment de l'installation de npm, mais il semble que vous puissiez y sentir "oui".
Après cela, vous pouvez écrire un programme JavaScript et l'exécuter comme suit pour le faire fonctionner.
./node_modules/.bin/babel-nom du script du nœud
Appeler l'API Ripple avec JavaScript
Cette fois, nous n'appelons qu'une seule API, donc l'exemple de RIpple est presque le même. Je pense donc que c'est plus facile à comprendre en regardant le code qu'en l'expliquant.
"use strict";
const RippleAPI = require("ripple-lib").RippleAPI;
const api = new RippleAPI({
server: "Entrez l'URL de l'API Ripple ici" // Public rippled server
});
api.connect().then(() => {
//Le traitement après la connexion au réseau Ripple est écrit ici.
//Plus précisément, il appelle l'API.
return api.getLedger()
}).then(info => {
//Vous serez ici lorsque le traitement de l'API sera terminé.
// info(Il y a une valeur de retour (le nom semble être gratuit).
//Cette fois, totalDrops est retiré et sorti.
//→ Ceci est défini dans "Valeur de retour" dans la documentation de l'API.
//C'est comme passer la chaîne de la console à Python.
console.log(info.totalDrops);
}).then(() => {
//Maintenant que je l'ai fait, je me déconnecte de Ripple.
return api.disconnect();
}).then(() => {
}).catch(console.error);
Tout ce que vous avez à faire est d'appeler l'API, d'afficher le résultat dans console.log et de notifier Python.
Entrez l'URL de l'API Ripple à la place de __server. __
Vous pouvez trouver l'URL sur le site suivant. https://ripple.com/build/rippled-apis/#websocket-api
Ou, puisque l'URL est écrite dans l'exemple ci-dessous, je pense que vous pouvez copier et coller à partir de là. https://ripple.com/build/rippleapi/#boilerplate
Dans cet article, je partirai du principe que le JavaScript ci-dessus est géré dans le fichier "get_totalDrops.js". Si vous l'exécutez seul, le nombre total de Drops apparaîtra comme ceci (cela prendra quelques secondes à 10 secondes pour apparaître).
$ ./node_modules/.bin//babel-node get_totalDrops.js
99997222654452897
Appelez JavaScript depuis Python.
Je l'ai écrit, mais cette fois, c'est une méthode très bâclée.
- Mettez le fichier python et le fichier JavaScript dans le même dossier
- Créez un environnement dans lequel node_js & rippleAPI et python peuvent être exécutés.
- Exécutez simplement en utilisant les commandes de python.
- La chaîne de console est renvoyée comme valeur de retour.
Les données à acquérir cette fois étant un nombre, elles seront fonctionnalisées ainsi.
import commands
RIPPLE_API_COMMAND = "./node_modules/.bin//babel-node get_totalDrops.js"
def get_totalDrops():
return long(commands.getoutput(RIPPLE_API_COMMAND))
Exécutez get_totalDrops.js, qui appelle l'API RIpple, dans commands.getoutput. Le résultat est une chaîne. Cette fois, seule la valeur numérique est sortie, elle est donc convertie en long et utilisée comme valeur de retour.
Cette fois, il n'y avait qu'une seule valeur de retour, mais si vous souhaitez renvoyer plusieurs résultats, vous pouvez utiliser csv ou quelque chose comme ça. Pour les données en vrac, je pense que nous avons besoin d'une autre logique.
Spécifications côté Python
Cette fois
- Collectez des données avec l'API Ripple
- Données de processus
- Visualisation des données traitées
J'essaierai toutes les étapes. Par conséquent, je vais essayer avec les exigences suivantes.
- Appelez RippleAPI / getLedger le nombre de fois spécifié à l'heure spécifiée.
- Calculez la différence entre l'heure précédente et la valeur de retour (totalDrops).
- Accumulez le total des gouttes et des différences.
- Après avoir appelé le nombre de fois spécifié, deux fichiers CSV seront générés en fonction des résultats accumulés.
Cette fois, je vais sortir le résultat avec R, donc je vais sortir les deux fichiers CSV suivants.
CSV pour les paramètres d'analyse
Saisissez ici l'heure de début et l'intervalle (unité: secondes) de chaque donnée. Ce qui suit est un exemple.
time, by
2016/8/20 7:59, 300
La première ligne est le titre et la deuxième ligne est l'heure de début et l'intervalle.
Données CSV
Mettez le résultat réel (totalDrops et différence) ici. Ce qui suit est un exemple.
total, diff
99997224489730292,0
99997224488731486,998806
99997224487789148,942338
99997224487350204,438944
99997224486780979,569225
De même, la première ligne est le titre, et à partir de la deuxième ligne, insérez l'une après l'autre avec le sentiment de totalDrops, différence. L'exemple ci-dessus est un exemple de 5 fois.
Code côté Python
Ce n'est pas si compliqué, donc je posterai le code d'un coup.
#!/usr/bin/python
# coding: UTF-8
import commands
import time
import datetime
# ---------Vous pouvez modifier les éléments suivants le cas échéant.
#Combien de secondes pour appeler l'API Ripple
RIPPLE_WAIT_SECS = 300
#Combien de fois appeler l'API RIpple.
RIPPLE_NUM_OF_GET_TOTALDROPS = 10
# ---------
#Nom du fichier CSV des paramètres
RIPPLE_PARA_CSV_FILENAME = "ripple_para.csv"
#nom de fichier csv avec les données de totalDrops et les différences
RIPPLE_DROP_CSV_FILENAME = "ripple_drops.csv"
#Faites-vous cette fois_totalDrops.opération de commande d'exécution js
RIPPLE_API_COMMAND = "./node_modules/.bin//babel-node get_totalDrops.js"
#Définition du code de saut de ligne
RIPPLE_CR = "\r\n"
#Appelez getLedger sur l'API Ripple. Il retourne avec une valeur numérique.
def get_totalDrops():
return long(commands.getoutput(RIPPLE_API_COMMAND))
#C'est gênant, alors j'en ai fait une classe.
class RippleTotalDros:
def __init__(self):
self.total = long(0)
self.diff = long(-1)
self.start_time = ""
self.drop_csv = ""
self.para_csv = ""
#Générer une chaîne en fonction de l'heure actuelle
# need_seconed =Vrai exemple: 2016/8/15 12:27:5
# need_seconed =Faux exemple: 2016/8/15 12:27
def get_date_time(self, need_second):
d = datetime.datetime.today()
text = str(d.year) + "/" + str(d.month) + "/" + str(d.day)
text += " " + str(d.hour) + ":" + str(d.minute)
if (need_second == True):
text += ":" + str(d.second)
return text
#Calculer la différence par rapport à la valeur de retour (totalDrops) de getLedger
#Enregistrer dans chaque variable membre
def calc_drop_data(self, result):
if self.diff >= 0:
self.diff = self.total - result
else:
self.diff = 0
self.total = result
#CSV pour le paramétrage est une variable membre para_Créé en csv
def make_para_csv(self):
self.start_time = self.get_date_time(False)
self.para_csv = "time, by" + RIPPLE_CR
self.para_csv += self.start_time + "," + str(RIPPLE_WAIT_SECS) + RIPPLE_CR
#Appelez RippleAPI pour collecter des données
#Appelez l'API et créez les données CSV des données en fonction du résultat.
#Ce processus prend un laps de temps spécifié x un nombre de fois spécifié, il prend donc du temps.
def collect_totalDrops(self):
self.drop_csv = "total, diff" + RIPPLE_CR
print "start to correct " + self.start_time
for i in xrange(RIPPLE_NUM_OF_GET_TOTALDROPS):
result = get_totalDrops()
self.calc_drop_data(result)
date_time = self.get_date_time(True)
print i , " :" + date_time + " total=" , self.total , " diff=" , self.diff
self.drop_csv += str(self.total) + "," + str(self.diff) + RIPPLE_CR
if i < RIPPLE_NUM_OF_GET_TOTALDROPS - 1:
time.sleep(RIPPLE_WAIT_SECS) #Si c'est le dernier, vous pouvez sortir sans attendre.
#Convertissez le fichier CSV créé en fichier.
def write_csv(self):
f = open(RIPPLE_PARA_CSV_FILENAME, "w")
f.write(self.para_csv)
f.close()
f = open(RIPPLE_DROP_CSV_FILENAME, "w")
f.write(self.drop_csv)
f.close()
# ---Principale
print "Ripple Collet totalDrops."
ripple = RippleTotalDros()
ripple.make_para_csv() #Création de données de paramètres CSV
ripple.collect_totalDrops() #Collecte de données et création de données CSV
ripple.write_csv() #Ecrire CSV dans un fichier
print "Complete. csv -> " + RIPPLE_DROP_CSV_FILENAME
Il a été écrit par une personne peu compétente, donc je pense que vous pouvez comprendre le contenu si vous le regardez en vous référant à w, aux commentaires, etc. Dans cet exemple, exécutez-le environ 10 fois toutes les 5 minutes.
Comme je l'ai écrit il y a quelque temps, on suppose que get_totalDrops.js est placé dans le même dossier et qu'il existe un environnement dans lequel node_js & rippleAPI et python peuvent être exécutés, alors soyez prudent. Quand je lance ce Python, cela ressemble à ceci:
$ python ./get_totalDrops.py
Ripple Collet totalDrops.
start to correct 2016/8/21 13:7
0 :2016/8/21 13:8:1 total= 99997222541580190 diff= 0
1 :2016/8/21 13:13:33 total= 99997222534612330 diff= 6967860
2 :2016/8/21 13:19:6 total= 99997222528462961 diff= 6149369
3 :2016/8/21 13:24:36 total= 99997222523885100 diff= 4577861
4 :2016/8/21 13:30:4 total= 99997222514133479 diff= 9751621
5 :2016/8/21 13:35:36 total= 99997222505328424 diff= 8805055
6 :2016/8/21 13:41:7 total= 99997222500019477 diff= 5308947
7 :2016/8/21 13:46:37 total= 99997222496816135 diff= 3203342
8 :2016/8/21 13:52:5 total= 99997222493532687 diff= 3283448
9 :2016/8/21 13:57:35 total= 99997222488190979 diff= 5341708
Complete. csv -> ripple_drops.csv
De plus, vous aurez deux fichiers CSV, ripple_para.csv et ripple_drops.csv.
Vérifiez le résultat avec R
Je suis presque un amateur en Python, mais R est plus amateur (ce que ce japonais w). Cette fois, plutôt qu'une analyse significative, il a une forte signification de confirmer s'il peut être visualisé. En créant le code, j'ai fait référence au site de M. Okumura ci-dessous.
https://oku.edu.mie-u.ac.jp/~okumura/stat/timeseries.html
__ Création de données de tracé __
J'ai fait les données originales de l'intrigue comme ça.
ripple.para = read.csv("ripple_para.csv")
ripple.by_csv = as.numeric(ripple.para[1,2])
ripple.start_time = as.character(ripple.para[1,1])
ripple.drops = read.csv("ripple_drops.csv")
ripple.matrix <- as.matrix(ripple.drops)
base_time = as.POSIXct(ripple.start_time)
time_scale = seq(base_time, by=ripple.by_csv, along.with=ripple.matrix[,2])
En bref, lisez csv et matrez les données. Puisque le temps est sur l'axe horizontal, j'ai l'impression de l'avoir ajusté.
__total Drops visualisation __
L'intrigue de totalDrops ressemble à ceci. Puisqu'il s'agit de totalDrpos, diff, l'axe des y est [, 1].
plot(time_scale, ripple.matrix[,1], type="o", pch=16, xlab="time(sec)", ylab="total drops")
Le résultat est comme ça.
Les chiffres diminuent progressivement.
__ Visualisation des différences __
Le graphique des différences ressemble à ceci. Puisqu'il s'agit de totalDrpos, diff, l'axe des y est [, 2].
plot(time_scale, ripple.matrix[,2], type="o", pch=16, xlab="time(sec)", ylab="drops")
Le résultat est le suivant.
C'est une différence, donc on a l'impression que ça marche.
Licence
Je l'ai utilisé ci-dessous. Merci d'avoir fourni le merveilleux logiciel.
- (Je vais l'écrire pour le moment ...) Le code ci-dessus est dans le domaine public. Bien entendu, personne ne subira de dommages lors de son utilisation. Faites juste attention là-bas.
- Python lui-même est une licence PSF (Python Software Foundation).
- ↑ Les informations sont [Python de Wikipedia](https://ja.wikipedia.org/wiki/Python#.E3.83.A9.E3.82.A4.E3.82.BB.E3.83.B3. E3.82.B9) est la source.
- Node.js est sous licence ici. Selon WikiPedia, il semble être sous licence MIT.
- C'est une licence de l'API Ripple, mais je pense que c'est probablement ceci. Hein ASIS?
- La licence R est ici. Je comprends que le principe est le système GPL.
c'est tout.
Recommended Posts