Hur man delegerar enkla rapporter till en robot. Att skriva en bot i Python och Google BigQuery

Har du uppgifter som upprepas dag efter dag, vecka efter vecka? Till exempel skriva rapporter. Du begär data, analyserar den, visualiserar den (gör grafer, diagram) och skickar den sedan till din chef. Men tänk om allt detta var automatiserat?

I den här handledningen kommer vi att skapa en bot för Telegram som hjälper till att automatisera rapportering. Och det häftigaste är att hela programmet kommer att bestå av endast 50 rader kod! Om du skapar en bot för Telegram för första gången bör du också läsa den här post.

Skillbox rekommenderar: Praktisk kurs Python-utvecklare från grunden.

Påminnelse: för alla läsare av "Habr" - en rabatt på 10 000 rubel när du anmäler dig till någon Skillbox-kurs med hjälp av "Habr"-kampanjkoden.

Komma igång

Installerar bibliotek

Vi kommer använda google-moln-bigquery för att hämta data från Google BigQuery. matplotlib, numpy и pandor hjälper dig att visualisera dina data. python-telegram-bot kommer att skicka den färdiga datan till Telegram.

pip3 installera google-cloud-bigquery matplotlib numpy pandas python-telegram-bot

Ansluter Google BigQuery API

Om vi ​​vill använda tjänsten måste vi ansluta Google BigQuery API. För att göra detta går vi till Google Developers Console och skapa ett nytt projekt (eller välj ett befintligt).

I kontrollpanelen väljer du AKTIVERA APIS OCH TJÄNSTER och leta efter BigQuery API.

Välj Aktivera för att ansluta API.

Skapa en kontonyckel

Låt oss gå till igen Google Developers Console, välj fliken Inloggningsuppgifter, Skapa inloggningsuppgifter och nyckel för tjänstkonto.

Sedan - Nytt servicekonto och ange namnet i fältet Servicekontonamn.

I rullgardinsmenyn Roll väljer du Projekt > Ägare och sedan Skapa.

Filen som kommer att laddas ner automatiskt heter creds.json.

Ställ in GOOGLE_APPLICATION_CREDENTIALS, ange sökvägen till creds.json i terminalen.

exportera GOOGLE_APPLICATION_CREDENTIALS='[PATH_TO_CREDS.JSON]'

Om allt gick bra är det dags att börja skriva programmet.

Skapa en applikation

För handledningen kommer vi att använda data från bigquery-public-data.stackoverflow, för vår rapport kommer vi att välja antalet dagliga publikationer.

Allt är ganska enkelt.

Fråga tabellen -> Visualisera data -> Spara visualiseringen -> Skicka bilden

Låt oss skapa en funktion för att definiera varje tråd.

Fråga till BigQuery

Först importerar vi biblioteket.

från google.cloud import bigquery

Vi skapar en funktion som heter query_to_bigquery, där parametern är query.

def query_to_bigquery(query):
    client = bigquery.Client()
    query_job = client.query(query)
    result = query_job.result()
    dataframe = result.to_dataframe()
    return dataframe

Denna funktion returnerar begäran som en dataram.

Visualisera data

För att lösa detta problem, välj matplotlib.

importera matplotlib.pyplot som plt

Vi behöver fem parametrar, där x är x-axelns data, x_label är titeln för axeln, y är y-axelns data, y_label är titeln för axeln och titel är titeln på hela visualiseringen.

def visualize_bar_chart(x, x_label, y, y_label, title):
    plt.title(title)
    plt.xlabel(x_label)
    plt.ylabel(y_label)
    index = np.arange(len(x))
    plt.xticks(index, x, fontsize=5, rotation=30)
    plt.bar(index, y)
    return plt

Spara bilden

Låt oss nu använda två funktioner för att skapa en visualisering och spara den.

Vi kommer att skicka antalet publicerade inlägg dagligen. Först skriver vi en förfrågan.

query = """
        SELECT DATE(creation_date) date, COUNT(*) total_posts
        FROM `bigquery-public-data.stackoverflow.post_history`
        GROUP BY 1
        HAVING date > DATE_SUB('2018-12-02', INTERVAL 14 DAY)
        ORDER BY 1
        """

Frågan hjälper till att samla in data under två veckor från och med den 2 december 2018.

Vi använder detta datum eftersom 2018-12-02 är den senaste datan som registrerats i bigquery-public-data.stackoverflow.post_history, i andra fall kan du använda CURRENT_DATE() för att få de senaste uppgifterna.

Anropa query_to_bigquery-funktionen för att hämta data.

dataram = query_to_bigquery(query)

Sedan använder vi kolumnen datumdata för x-axeln och kolumnen total_posts för y-axeln.

x = dataram['date'].tolist()
y = dataram['total_posts'].tolist()

Vi visualiserar det med funktionen visualize_bar_chart och sparar det som en bild.

plt = visualize_bar_chart(x=x, x_label='Datum', y=y, y_label='Totalt antal inlägg', title='Dagliga inlägg')
plt.savefig('viz.png')

Vi lindar in den här koden i en funktion som heter get_and_save_image.

def get_and_save_image():
    query = """
            SELECT DATE(creation_date) date, COUNT(*) total_posts
            FROM `bigquery-public-data.stackoverflow.post_history`
            GROUP BY 1
            HAVING date > DATE_SUB('2018-12-02', INTERVAL 14 DAY)
            ORDER BY 1
            """
    dataframe = query_to_bigquery(query)  
    x = dataframe['date'].tolist()
    y = dataframe['total_posts'].tolist()
    plt = visualize_bar_chart(x=x, x_label='Date', y=y, y_label='Total Posts', title='Daily Posts')
    plt.savefig('viz.png')

Skicka en bild

För att kunna skicka en rapport till mottagaren måste du känna till parametern chat_id.

Vi använder användarinfobot och skriv /start. Boten svarar med nödvändig information, chat_id finns i id-fältet.

Låt oss nu skapa funktionen send_image. Den kommer att använda get_and_save_image-funktionen för att hämta och spara bilden. Och sedan skickar vi allt till rätt kontakt.

def send_image(bot, update):
    get_and_save_image()
    chat_id = 'CHAT_ID_RECEIVER'
    bot.send_photo(chat_id=chat_id, photo=open('viz.png','rb'))

Huvudprogram

Slutligen skapar vi en annan funktion, main, för att starta applikationen. Glöm inte att ändra YOUR_TOKEN för boten.

Kom ihåg: det här programmet skickar bilden automatiskt vid den tid du anger. Vi kommer till exempel att skicka en rapport klockan nio på morgonen varje dag.

def main():
    updater = Updater('YOUR_TOKEN')
    updater.job_queue.run_daily(send_image, time=datetime.datetime.strptime('9:00AM', '%I:%M%p').time(), days=(0,1,2,3,4,5,6))
    updater.start_polling()
    updater.idle()
 
if __name__ == '__main__':
    main()

Som ett resultat kommer vår ansökan att se ut så här:

from google.cloud import bigquery
from telegram.ext import Updater
 
import matplotlib.pyplot as plt
import numpy as np
import datetime
 
def query_to_bigquery(query):
    client = bigquery.Client()
    query_job = client.query(query)
    result = query_job.result()
    dataframe = result.to_dataframe()
    return dataframe
 
def visualize_bar_chart(x, x_label, y, y_label, title):
    plt.title(title)
    plt.xlabel(x_label)
    plt.ylabel(y_label)
    index = np.arange(len(x))
    plt.xticks(index, x, fontsize=5, rotation=30)
    plt.bar(index, y)
    return plt
 
def get_and_save_image():
    query = """
            SELECT DATE(creation_date) date, COUNT(*) total_posts
            FROM `bigquery-public-data.stackoverflow.post_history`
            GROUP BY 1
            HAVING date > DATE_SUB('2018-12-02', INTERVAL 14 DAY)
            ORDER BY 1
            """
    dataframe = query_to_bigquery(query)  
    x = dataframe['date'].tolist()
    y = dataframe['total_posts'].tolist()
    plt = visualize_bar_chart(x=x, x_label='Date', y=y, y_label='Total Posts', title='Daily Posts')
    plt.savefig('viz.png')
 
def send_image(bot, update):
    get_and_save_image()
    chat_id = 'CHAT_ID_RECEIVER'
    bot.send_photo(chat_id=chat_id, photo=open('viz.png', 'rb'))
 
def main():
    updater = Updater('YOUR_TOKEN')
    updater.job_queue.run_daily(send_image, time=datetime.datetime.strptime('9:00AM', '%I:%M%p').time(), days=(0,1,2,3,4,5,6))
    updater.start_polling()
    updater.idle()
 
if __name__ == '__main__':
main()

Spara filen och kalla den main.py.

Vi startar applikationen genom att ange kommandot i terminalen:

python3 main.py

Allt är klart. Nu har vi en robot bestående av 50 rader kod som genererar rapporter utan vår inblandning.

Låt oss kolla boten hencegenom att välja kommandot /send.

Du kan få den färdiga koden på min GitHub.

Skillbox rekommenderar:

• Tvåårig praktisk kurs "Jag är en PRO webbutvecklare".
• Onlinekurs "C#-utvecklare från 0".
• Praktisk årskurs "PHP-utvecklare från 0 till PRO".

Källa: will.com