Obtenez un flux RSS en utilisant Python + pandas → Publiez sur Mattermost et enregistrez dans DB

Ce que j'ai fait

Je voulais présenter Mattermost et essayer quelque chose, j'ai donc créé un programme pour publier des flux RSS. (Plus tard, c'est un secret que j'ai remarqué qu'il y avait un projet officiel)

J'ai pensé que cela pouvait être appliqué de différentes manières, j'ai donc traité le flux acquis avec des pandas. J'ai décidé de le stocker dans la DB.

• Pour ceux qui disent "Mattermost" ici

environnement

• CentOS7
• Python2.7
  • pandas
  • feedparser
  • sqlalchemy
  • requests
• PostgreSQL9.5
• MatterMost

PostgreSQL a été introduit à partir de l'image docker.

docker pull postgres:9.5
docker run -p 5432:5432 --name postgres-server -v /var/lib/postgresql:/var/lib/postgresql:rw  postgres:9.5
firewall-cmd --permanent --add-port=5432/tcp
firewall-cmd --reload

Cela devrait lancer un conteneur PostgreSQL qui peut être connecté à distance pour le moment. docker est pratique. .. ..

Les autres constructions d'environnement sont omises et Python est implémenté dans l'environnement pyenv.

1. Obtenez le flux RSS.

Nous utilisons une bibliothèque Python appelée feedparser. Je l'ai installé avec pip, faisant référence à cette zone.

http://qiita.com/shunsuke227ono/items/da52a290f78924c1f485

import feedparser

RSS_URL = "http://b.hatena.ne.jp/hotentry/it.rss"
print("Start get feed from %s" % (RSS_URL))
feed = feedparser.parse(RSS_URL)

Vous pouvez maintenant obtenir le flux. (En passant, j'ai eu une entrée chaude dans la catégorie technologie de Hatena.)

2. Extrayez le flux récupéré dans pandas.DataFrame

Mappez sur pandas.DataFrame pour faciliter le traitement futur.

import pandas as pd
entries = pd.DataFrame(feed.entries)

...la fin. pandas est excellent.

Dans le cas du flux RSS d'Hatena, les 12 colonnes d'éléments suivantes ont été acquises.

• content
• hatena_bookmarkcount
• id
• link
• links
• summary
• summary_detail
• tags
• title
• title_detail
• updated
• updated_parsed

À ce stade, vous pouvez manipuler librement les données avec la fonction pandas.

3. Rechercher de nouveaux flux

feedparser est très pratique, mais il récupère le flux au moment de l'accès, il sera donc dupliqué avec le flux obtenu dans le passé.

C'est là que le sens de l'expansion vers DataFrame ressort! Voici un exemple d'extraction et d'affichage uniquement de nouveaux flux en utilisant DataFrame.

already_print_feeds = pd.Series()

while True:
        time.sleep(300)
        feed = feedparser.parse(RSS_URL)
        entries = pd.DataFrame(feed.entries)
        new_entries = entries[~entries['id'].isin(already_print_feeds)]
        if not new_entries.empty:
            for key, row in new_entries.iterrows():
                feedinfo = "[**%s**](%s)\n\n>%s"%(row['title'],row['link'],tag_re.sub('',row['summary']))
                print(feedinfo)
        already_print_feeds = already_print_feeds.append(new_entries['id'])

Un petit commentaire

new_entries = entries[~entries['id'].isin(already_print_feeds)]

Il extrait uniquement les nouveaux arrivants du flux RSS récupéré.

On suppose que ʻalready_print_feeds contient l''id des flux RSS obtenus jusqu'ici.

Ensuite, parmi les flux stockés dans les «entrées», Puisque Serires avec True défini uniquement pour les nouvelles lignes est renvoyé, Si vous spécifiez ceci comme index des «entrées», vous ne pouvez extraire que les nouveaux arrivants.

~entries['id'].isin(already_print_feeds)
# =>
0     False
1     True # => ★New!
2     False
3     False
4     False
5     False
6     False
7     False
8     False
9     False
10    False
11    False
12    False
13    False
14    False
15    False
16    False
17    False
18    False
19    True # => ★New!
20    False
21    False
22    False
23    False
24    False
25    False
26    False
27    False
28    False
29    False
Name: id, dtype: bool

ʻAlready_print_feeds` doit être ajouté avec l'ID du nouveau flux affiché jusqu'à présent.

already_print_feeds = already_print_feeds.append(new_entries['id'])

: avertissement: Cependant, avec le code ci-dessus, les données seront accumulées indéfiniment dans ʻalready_print_feeds`, donc elles tomberont en panne un jour (mémoire). Clignotons une fois par jour ou lisons dans la base de données

4. Enregistrer dans la base de données (PostgreSQL)

Enregistrez le flux RSS récupéré dans PostgreSQL. Cependant, les colonnes sont réduites comme suit.

• id
• link
• title
• summary
• updated

Commencez par créer une table dans la base de données.

create table feed ( id text primary key , link text, title text, summary text, updated timestamp );

Pour le moment, j'ai mis une contrainte de clé primaire dans id, et mis à jour est un type d'horodatage. (Il semble que la version mise à jour du flux Hatena puisse être INSÉRÉE en tant que type d'horodatage tel quel.)

from sqlalchemy import create_engine

DATABASE_CONN = "postgresql://xxxx:xxxx@xxxxx:xxx/xxxx"
DATABASE_TABLE = "feed"
# connect database
engine = create_engine(DATABASE_CONN)

# Store database
stored_entries = new_entries.ix[:, [
                "id", "link", "title", "summary", "updated"]]
stored_entries.to_sql(DATABASE_TABLE, engine, index=False, if_exists='append')

Utilisez la méthode to_sql de DataFrame.

• index=False

Ce faisant, la colonne d'index ne sera pas ajoutée arbitrairement au moment du stockage,

• if_exists='append'

Ensuite, le comportement consiste à ajouter des données à la table qui existe déjà.

5. Publiez sur le sujet le plus

Il est très facile de publier avec une bibliothèque Python appelée request qui envoie des requêtes HTTP.

import requests
import json

mattermosturl = "URL de webhook la plus récente"
username = "Nom préféré"
header = {'Content-Type': 'application/json'}
payload = {
        "text": feedinfo,
        "username": username,
        }

resp = requests.post(mattermosturl,
                     headers=header, data=json.dumps(payload))

alors

Depuis que je l'ai mappé aux pandas, Je veux aussi faire des choses comme l'apprentissage automatique.