Il mio primo progetto scritto in Python ha riguardato la creazione di un piccolo bot che potesse upvotare e commentare i post sotto cui io abbia lasciato in precedenza un commento contenente una determinata parola chiave: la sua utilità è quella di poter utilizzare un solo account per decidere come e se upvotare un post con il mio account secondario.

Alle volte infatti potrei voler upvotare solo con il mio account principale, altre solo con quello secondario, altre ancora con entrambi ma con percentuali diverse... ecco perchè configurare una curation trail con hive.vote in questi casi potrebbe essere troppo limitante, mentre avere un proprio bot personalizzato che consenta, di volta in volta, di scegliere cosa fare permette di essere molto più flessibili ed evitare di sprecare preziosi upvotes.

Rispetto al codice condiviso la scorsa volta ho apportato alcune piccole migliorie, alcune suggeritemi da altri utenti, altre aggiunte per rendere il codice più robusto e meno incline a crash imprevisti.

Ora sto rifinendo alcune ultime piccole cose, ma intanto potete già trovare lo script su GitHub... o almeno potrete trovarlo appena avrò impostato la privacy su "pubblica" 😂 per cui se clicclate sul link a poca distanza dalla pubblicazione di questo post non vedrete, purtroppo, ancora nulla.

Adesso si passa ad un nuovo progetto!

Finito (quasi) il primo progetto, è tempo di passare a qualcosa di diverso, nell'ottica di provare ad imparare cose sempre nuove!

Stavolta l'idea di cosa realizzare deriva da un suggerimento di @stewie.wieno, che mi ha chiesto se, sfruttando Python, fosse possibile creare qualcosa che potesse agevolare la creazione di una sorta di curation trail a sostegno degli utenti italiani su Hive.

La mia idea è stata perciò quella di progettare uno script che avesse le seguenti funzioni:

• individuare i post muniti di un particolare tag (es. ita);
• controllare che il post sia scritto in lingua italiana;
• controllare che il post abbia almeno 500 parole (o 1000 se il post è scritto in due lingue).

Se questi requisiti sono soddisfatti il post viene aggiunto ad un'apposita lista.

Qui finisce il compito di questo primo script.

La lista può così essere controllata manualmente da uno o più curatori che si accertino che i post siano di qualità, non siano spam e non violino qualche regola di Hive.

Dopo di che vorrei creare un secondo script che si occupi di prendere la lista ripulita e proceda ad upvotare i post selezionati, lasciando a ciascuno un commento informativo.

In questo modo il lavoro dei curatori sarebbe notevolmente semplificato e velocizzato, occupandosi i due script di praticamente tutta la procedura in maniera automatizzata.

Ovviamente questo è solo un inizio, ma costruire uno strumento del genere sembrava un esercizio interessante, per cui ho voluto provare a fare questo piccolo esperimento :)

Ed ecco il codice!

A seguire il codice del primo dei due script a cui sto lavorando, già funzionante e pronto per essere rifinito:

#!/usr/bin/env python3
"""A script to simplify curation on Hive"""
from beem import Hive
from beem.blockchain import Blockchain
import beem.instance
import os
import json
import markdown
from bs4 import BeautifulSoup
import re
from langdetect import detect_langs, LangDetectException as lang_e

# Instanciate Hive
HIVE_API_NODE = "https://api.deathwing.me"
HIVE = Hive(node=[HIVE_API_NODE])

beem.instance.set_shared_blockchain_instance(HIVE)


def get_block_number():

    if not os.path.exists("last_block.txt"):
        return None

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


def set_block_number(block_num):

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


def convert_and_count_words(md_text):
    # Convert text from markdown to HTML
    html = markdown.markdown(md_text)

    # Get text
    soup = BeautifulSoup(html, "html.parser")
    text = soup.get_text()

    # Count text words
    words = re.findall(r"\b\w+\b", text)
    return len(words)


def text_language(text):
    # Detect languages
    try:
        languages = detect_langs(text)
    except lang_e:
        return False, 0

    # Count languages
    num_languages = len(languages)

    # Sort languages from more to less probable
    languages_sorted = sorted(languages, key=lambda x: x.prob, reverse=True)

    # Check most probable languages (up to 2)
    top_languages = (
        languages_sorted[:2] if len(languages_sorted) > 1 else languages_sorted
    )

    # Check it target language is among the top languages
    contains_target_lang = any(lang.lang == "it" for lang in top_languages)

    # Return True/False and number of languages detected
    return contains_target_lang, num_languages


def hive_comments_stream():

    blockchain = Blockchain(node=[HIVE_API_NODE])

    start_block = get_block_number()

    for op in blockchain.stream(
        opNames=["comment"], start=start_block, threading=False, thread_num=1
    ):
        set_block_number(op["block_num"])

        # Skip comments
        if op.get("parent_author") != "":
            continue

        # Check if there's the key "json_metadata"
        if "json_metadata" not in op.keys():
            continue

        # Deserialize 'json_metadata'
        json_metadata = json.loads(op["json_metadata"])

        # Check if there's the key "tags"
        if "tags" not in json_metadata:
            continue

        # Check if there's the tag we are looking for
        if "ita" not in json_metadata["tags"]:
            continue

        post_test = op.get("body")

        # Check post language
        is_valid_language, languages_num = text_language(post_test)

        if is_valid_language == False:
            continue

        # Check post length
        word_count = convert_and_count_words(post_test)

        if languages_num == 1:
            if word_count < 500:
                print("Post is too short")
                continue

        if languages_num > 1:
            if word_count < 1000:
                print("Post is too short")
                continue

        # data of the post
        post_author = op["author"]
        post_permlink = op["permlink"]
        post_url = f"https://peakd.com/@{post_author}/{post_permlink}"
        terminal_message = (
            f"Found eligible post: " f"{post_url} " f"in block {op['block_num']}"
        )
        print(terminal_message)

        with open("urls", "a", encoding="utf-8") as file:
            file.write(post_url + "\n")


if __name__ == "__main__":

    hive_comments_stream()

Stavolta non ci sono templates o file di configurazione.

Come l'altra volta sarei felicissimo di ricevere suggerimenti e consigli sul come rendere il codice ancora più efficiente e corretto :)

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!