Partiamo subito con una piccola premessa: non sono un programmatore.

Nella vita ho studiato tutt'altro ed il mio lavoro non richiede competenze informatiche che vadano al di là del saper utilizzare Word, Outlook e poco più.

Non ho basi di alcun tipo, perciò.

Tuttavia ho sempre avuto una passione per l'informatica e nel mio tempo libero mi sono spesso ritrovato a cercare di imparare quante più cose potevo: assemblare un pc, configurare un modem, utilizzare programmi di editing immagini e video, installare un sistema operativo, imparare un po' di HTML... insomma, niente di fantascientifico, ma nel mio piccolo ho sempre cercato di aggiungere qualche informazione in più, ampliando le mie conoscenze come potevo.

Ed è proprio con questo obiettivo sempre in testa che qualche mese fa mi sono posto una nuova sfida: provare ad imparare un linguaggio di programmazione, come Python.

Perchè Python?

Perchè leggendo a giro sembrava il più indicato per un neofita, insieme a Javascript.

Python infatti è estremamente "leggibile", nel senso che, una volta imparate un minimo di basi, lo si può letteralmente leggere come se fosse un testo, per quanto scritto in maniera molto stringata e concisa.

Per uno che non sapeva niente di niente mi è sembrato un bel pregio, e così per qualche settimana mi sono messo sotto e, tra un impegno e l'altro, ho cercato di leggere ed imparare quante più cose potevo.

Poi sul lavoro è arrivato un periodo molto faticoso e carico di impegni e per qualche mese ho dovuto mettere tutto in pausa.

Ora, che finalmente posso godermi un po' di riposo e tranquillità durante le ferie estive, ho deciso di riprendere da dove mi ero fermato e, con l'obiettivo di iniziare a mettere in pratica quel poco che ho imparato, ho deciso di provare a scrivere il codice per un bot.

E non un bot qualsiasi, ma un bot che funziona su Hive!

Adoro Hive, per cui ho pensato che avesse senso sviluppare qui il mio primo piccolo progetto.

E cosa fa questo bot?

Qualcosa di molto semplice e che già fanno altri bot presenti su Hive: nel momento in cui viene inserita in un commento la parola chiave (ad esempio !CURATE), il bot la rileva e, a seconda della configurazione scelta e se il comando proviene da un account abilitato, upvota e/o commenta il post sotto cui è stato lasciato il commento.

Se avete mai visto il bot @tipu all'opera, ecco, questo funziona esattamente alla stessa maniera, almeno nel comportamento base.

Il mio codice è infatti molto semplice e per ora non ho implementato funzioni ulteriori che possano renderlo ancora più versatile ed utile.

Per scriverlo mi sono basato su questo bot creato dal Hive Pizza Team, che ho usato come base, dopo averlo ripulito delle funzioni che non mi servivano, aggiornando leggermente alcune parti del codice ed inserendo una nuova funzione per upvotare il post bersaglio.

All'inizio non sapevo da che punto partire, ma dopo qualche ora di lavoro sono riuscito a farlo funzionare e ho piano piano perfezionato il funzionamento arrivando al risultato che volevo.

Lavoro finito?

Assolutamente no!

Infatti:

1. non ho ancora testato in maniera estensiva il bot e ci sono almeno un paio di eccezioni che vogliono implementare nel codice, così da renderlo ancora più robusto;
2. devo poi capire come condividerlo su GitHub, in modo da renderlo accessibile a chiunque;
3. infine, se il corretto funzionamento fosse confermato, vorrei considerare la possibilità di crearmi un piccolo server personale su cui hostarlo, in modo da poterlo utilizzare a mio piacimento.

Un piccolo sogno sarebbe poi renderlo accessibile a chiunque tramite un apposito sito, creando un'interfaccia con cui collegarsi e settare il bot a proprio piacimento... ma prima di arrivare a questo punto, semmai ci arriverò, ce ne vorrà di tempo 😅

Ed ecco il codice!

Dopo tutte queste chiacchiere, è il momento di condividere il codice che compone il mio primo progetto, che, come detto sopra, è basato sul codice di un bot creato dal Hive Pizza Team.

#!/usr/bin/env python3
"""A script to find and react to commands in comments"""
from beem import Hive, exceptions
from beem.blockchain import Blockchain
from beem.comment import Comment
import beem.instance
import os
import jinja2
import configparser
import time
import re

# Global configuration

BLOCK_STATE_FILE_NAME = "last_block.txt"

config = configparser.ConfigParser()
config.read("config")

ENABLE_COMMENTS = config["Global"]["ENABLE_COMMENTS"] == "True"
ENABLE_UPVOTES = config["Global"]["ENABLE_UPVOTES"] == "True"

CALLER_ACCOUNT = config["Global"]["CALLER_ACCOUNT"]
ACCOUNT_NAME = config["Global"]["ACCOUNT_NAME"]
ACCOUNT_POSTING_KEY = config["Global"]["ACCOUNT_POSTING_KEY"]
HIVE_API_NODE = config["Global"]["HIVE_API_NODE"]
HIVE = Hive(node=[HIVE_API_NODE], keys=[config["Global"]["ACCOUNT_POSTING_KEY"]])
HIVE.chain_params["chain_id"] = (
    "beeab0de00000000000000000000000000000000000000000000000000000000"
)
beem.instance.set_shared_blockchain_instance(HIVE)

BOT_COMMAND_STR = config["Global"]["BOT_COMMAND_STR"]

# END Global configuration


print("Configuration loaded:")
for section in config.keys():
    for key in config[section].keys():
        if "_key" in key:
            continue  # don't log posting keys
        print(f"{section}, {key}, {config[section][key]}")


# Markdown template for comment
comment_curation_template = jinja2.Template(
    open(os.path.join("templates", "comment_curation.template"), "r").read()
)


def get_block_number():

    if not os.path.exists(BLOCK_STATE_FILE_NAME):
        return None

    with open(BLOCK_STATE_FILE_NAME, "r") as infile:
        block_num = infile.read()
        return int(block_num)


def set_block_number(block_num):

    with open(BLOCK_STATE_FILE_NAME, "w") as outfile:
        outfile.write(f"{block_num}")


def give_upvote(parent_post, author, vote_weight):
    if ENABLE_UPVOTES:
        print("Upvoting!")
        parent_post.upvote(weight=vote_weight, voter=author)
        # sleep 3s before continuing
        time.sleep(3)
    else:
        print("Upvoting is disabled")


def post_comment(parent_post, author, comment_body):
    if ENABLE_COMMENTS:
        print("Commenting!")
        parent_post.reply(body=comment_body, author=author)
        # sleep 3s before continuing
        time.sleep(3)
    else:
        print("Posting is disabled")


def hive_comments_stream():

    blockchain = Blockchain(node=[HIVE_API_NODE])

    start_block = get_block_number()

    # loop through comments
    for op in blockchain.stream(
        opNames=["comment"], start=start_block, threading=False, thread_num=1
    ):

        set_block_number(op["block_num"])

        # skip comments that don't include the bot's command
        if BOT_COMMAND_STR not in op["body"]:
            continue

        # skip comments that don't come from an authorized caller account
        if CALLER_ACCOUNT not in op["author"]:
            continue

        # skip posts that don't have an author
        if "parent_author" not in op.keys():
            continue

        # vote weight
        if ENABLE_UPVOTES:
            command = re.compile(rf"{BOT_COMMAND_STR} (-?(100|[1-9]?[0-9]))")
            try:
                vote = re.search(command, op["body"])
                vote_weight = int(vote.group(1))
            except AttributeError:
                print("Upvote not specified!")
                continue
        else:
            vote_weight = 0

        # data of the post to be upvoted and/or replied
        author_account = op["author"]
        comment_permlink = op["permlink"]
        parent_author = op["parent_author"]
        reply_identifier = f"{parent_author}/{op['parent_permlink']}"
        terminal_message = (
            f"Found {BOT_COMMAND_STR} command: "
            f"https://peakd.com/{comment_permlink} "
            f"in block {op['block_num']}"
        )
        print(terminal_message)

        try:
            post = Comment(reply_identifier, api="condenser")
        except beem.exceptions.ContentDoesNotExistsException:
            print("Post not found!")
            continue

        # leave an upvote and/or a comment
        comment_body = comment_curation_template.render(
            target_account=parent_author,
            author_account=author_account,
        )
        give_upvote(post, ACCOUNT_NAME, vote_weight)
        post_comment(post, ACCOUNT_NAME, comment_body)


if __name__ == "__main__":

    hive_comments_stream()

Questo è invece il file di configurazione:

[Global]
; Command the bot should listen for
BOT_COMMAND_STR = !CURATE
; Disable to stop the bot from posting comments
ENABLE_COMMENTS = True
; Disable to stop the bot from upvoting
ENABLE_UPVOTES = True
; Accounts allowed to call the bot
CALLER_ACCOUNT = arc7icwolf
; Account the bot will post and upvote from
ACCOUNT_NAME = wolf-lord
; Posting key for the account
ACCOUNT_POSTING_KEY = xxxxxx
; Hive API node to use for read/write/upvote ops
HIVE_API_NODE = https://api.deathwing.me

E questo il template con cui comporre il commento lasciato dal bot:

Hi @{{target_account}}, your post has been curated by @{{author_account}}.

Ovviamente sono aperto a suggerimenti, correzioni e miglioramenti!

Non ho mai fatto qualcosa del genere, per cui spero di non aver scritto troppe scemenze o violato qualche regola di qualche tipo... nel caso fatemelo sapere e provvederò a rimediare :)

immagini di proprietà dei rispettivi proprietari

a supporto della community #OliodiBalena, il 3% delle ricompense di questo post va a @balaenoptera

Se sei arrivato a leggere fin qui, grazie! Se hai voglia di lasciare un upvote, un reblog, un follow, un commento... be', un qualsiasi segnale di vita, in realtà, è molto apprezzato!