Cosa fare quando il tuo podcast preferito viene rimosso da Spotify

Io sono da sempre un appassionato di musica RnB/Soul e il conduttore radiofonico che ho sempre seguito negli anni è Massimo Oldani.
Massimo iniziò la vera carriera radiofonica a radio Milano International dal 1981, come conduttore di programmi a forte impronta black, le classifiche black single, la black countdown e via così, fino ad arrivare a Vibe su radio Capital, tuttora in onda.

Da circa 4 anni, il programma Vibe era quotidianamente disponibile su Spotify, con un archivio e una comodità di fruizione fantastica.

Fino a che, circa alla fine di aprile 2024, Vibe scompare misteriosamente dalla lista dei podcast di Spotify.

Le opzioni:

  • Sito di Radio Capital: pubblicità all’inizio del podcast e impossibilità di fruizione da smartphone
  • App One Podcast: un’altra app sul telefono? No grazie.
  • Amazon Prime Music: non ho Amazon prime.

Ok, che si fa?
Me lo faccio da solo il servizio podcast.

Gli strumenti:

  1. Telegram
  2. VPS
  3. Docker
  4. Un po’ di codice (bash scripting e python)

Il caposaldo Telegram.

Il servizio IM di Pavel Durov è famoso per i sui canali con modalità di bot pushing e, soprattutto, per l’approccio unlimited storage.
Il primo passo quindi è stato aprire il canale telegram t.me/TVMORC (acronimo di The Vibe Massimo Oldani Radio Capital)

Per popolare di contenuti il canale, occorre anche un bot per lo scripting in automatico. Ho quindi creato tramite la procedura ben documentata di Telegram (https://core.telegram.org/bots), il bot @TVMOPusher.

A questo punto, avrei potuto far girare gli script, ottenere la registrazione giornaliera dal sito di Radio Capital e fare upload tramite le API del bot.
Ma Telegram ha una policy di limite di 50MB e ogni puntata di Vibe è di circa 96 MB. Per ovviare a questo vincolo, o si acquista un abbonamento a Telegram o si usa un telegram-bot-api proxy; in questo modo il limite di upload si alza a 2GB per ciascun file.

Per poter usare il telegram-bot-api c’è bisogno di una chiave API (ID e HASH).
La procedura per ottenerla è ben descritta qui: https://core.telegram.org/api/obtaining_api_id

Ottimo. Ero quindi in possesso di:
Un canale telegram
Un bot già unito al canale
Le credenziali di API development

L’ambiente telegram era pronto, dovevo concentrarmi sulla parte VPS.

Il motorino push pull

  1. La VPS
    Per prima cosa avevo bisogno di accendere una VPS. Siccome è un progetto ludico e non a fini di lucro, avevo bisogno di trovare un servizio di VPS con il massimo delle prestazioni per prezzo pagato.
    Lasciando perdere VPS sconosciute a prezzi super aggressivi (si trova persino roba a 3€/mese) mi sono focalizzato su Contabo che per 5.49€ mi da 4 core a 3GhZ, 6 GB RAM e 400GB SSD. Con una bella Debian 12 e con Docker ho tutti gli strumenti per poter iniziare a costruire il mio motore cattura e spara puntate.
  2. Docker Container
    Uso il container di aiogram/telegram-bot-api https://github.com/aiogram/telegram-bot-api
    Creo il file yaml di compose:
version: '3.7'

services:
  telegram-bot-api:
    image: aiogram/telegram-bot-api:latest
    environment:
      TELEGRAM_API_ID: "<api-id>"
      TELEGRAM_API_HASH: "<api-hash>"
    volumes:
      - telegram-bot-api-data:/var/lib/telegram-bot-api
    ports:
      - "8081:8081"

volumes:
  telegram-bot-api-data:

È sufficiente inserire le TELEGRAM_API_ID e le TELEGRAM_API_HASH ottenute prima dalla pagina di core.telegram.org ed eseguire con docker-compose up

Voilà il mio telegram-bot -api è pronto a proxare e a caricare fino a 2GB di attachment.

  1. Python scripts.
    Ho bisogno di due scripts. Uno che mi scarichi la puntata poco dopo che è terminata e disponibile sul sito di Capital e uno che mi faccia il push sul canale telegram, via bot-api.
    Il primo script python, quello che scarica la puntata:
import requests
import datetime

def download_radio_program(url_template):
  """
  Scarica un programma radio da una URL con schema variabile in base all'ora e alla data.

  Args:
    url_template: La URL con lo schema variabile, ad esempio "https://media.capital.it/year/month/date/episodes/vibe/vibe_yearmonthdate_200000.mp3".

  Returns:
    Nessun valore, salva il file MP3 nella directory corrente.
  """

  # Ottieni la data e l'ora attuali
  now = datetime.datetime.now()

  # Sostituisci i segnaposto nella URL con i valori attuali
  url = url_template.replace("year", str(now.year))
  url = url.replace("month", str(now.month).zfill(2))
  url = url.replace("date", str(now.day).zfill(2))
  url = url.replace("hour", str(now.hour).zfill(2))
  url = url.replace("minute", str(now.minute).zfill(2))

  # Scarica il file MP3
  response = requests.get(url)

  # Controlla se il download è andato a buon fine
  if response.status_code == 200:
    # Salva il file MP3 nella directory corrente
    with open(f"vibe_{now.strftime('%Y%m%d_%H%M')}.mp3", "wb") as f:
      f.write(response.content)
    print(f"Programma radio scaricato da {url}")
  else:
    print(f"Errore durante il download del programma radio da {url}: {response.status_code}")

# Esempio di utilizzo
url_template = "https://media.capital.it/year/month/date/episodes/vibe/vibe_yearmonthdate_200000.mp3"
download_radio_program(url_template)

Il file fa una ricerca alla URL https://media.capital.it/year/month/date/episodes/vibe/vibe_yearmonthdate_200000.mp3 dove year/month/date e yearmonthdate vengono sostituiti dalla data in cui viene fatto partire lo script.

A questo punto ho il mio mp3 fresco fresco nella home directory del mio VPS.
Creo una directory di appoggio su cui spostarlo, la chiamo TVMO

Ecco quindi che entra in campo il secondo script, il caricatore di file da directory.

import os
import requests

def upload_directory(bot_token, chat_id, directory_path, caption=None):
  """Uploads all files from a directory to a Telegram channel.

  Args:
      bot_token: Your bot's API token.
      chat_id: The ID of the Telegram channel.
      directory_path: Path to the directory containing the files.
      caption: Optional caption for each file (as a string).
  """
  url = f"http://localhost:8081/bot{bot_token}/sendAudio"
  for filename in os.listdir(directory_path):
    file_path = os.path.join(directory_path, filename)
    # Check if it's a file (not a directory)
    if os.path.isfile(file_path):
      files = {'audio': open(file_path, 'rb')}
      params = {'chat_id': chat_id}
      if caption:
        params['caption'] = caption
      response = requests.post(url, files=files, params=params)

      if response.status_code == 200:
        print(f"File uploaded: {filename}")
      else:
        print(f"Error uploading {filename}: {response.json()}")

# Replace with your actual bot token and channel ID
bot_token = "mybotoken"
chat_id = "mychannelID"
directory_path = "/home/anton/TVMO"  # Replace with your directory path
caption = "Il podcast The Vibe del giorno"  # Optional caption

upload_directory(bot_token, chat_id, directory_path, caption)

Anche qui è necessario cambiare i valori di bot token (ottenibile così https://www.cytron.io/tutorial/how-to-create-a-telegram-bot-get-the-api-key-and-chat-id)

Ci siamo.

Un piccolo script bash per raggruppare tutta la procedura:

#!/bin/bash
echo "inizio a scaricare il file da web capital";
python3 /home/anton/capital.py;
mv *.mp3 /home/anton/TVMO;
python3 /home/anton/directory.py;
rm /home/anton/TVMO/*.mp3;
echo "finito, la puntata è stata caricata sul canale Telegram"

La programmazione cron 24 minuti dopo le 22 dal lunedì al venerdì, quando il file è già presente nel sito di Capital.

# m h
dom mon dow
command
MAILTO=""
24 22 * * 1-5 /home/anton/max

Lo script è in produzione ormai dal giorno 8 maggio 2024 e non ha perso mai un colpo 🙂

E se anche voi siete dei fan di Massimo Oldani e Vibe, potete iscrivervi al canale telegram https://t.me/TVMORC

Comments are closed.