Reproducir videos con MPV, mediante Python.

La reproducción de videos es una de las formas favoritas de entretenimiento de la gran mayoría de los seres humanos. Ya sean películas, documentales, video clips, grabaciones privadas o cualquier otro formato existente.

Nos pasamos gran parte de nuestro tiempo libre, o incluso no tan libre, visualizando todo tipo de contenidos audio visuales, especialmente del inmenso océano de material videográfico que es YouTube.

MPV es un reproductor multimedia gratuito, de código abierto y multiplataforma.

En Mac se puede instalar facilmente utilizando brew, con la siguiente instrucción en la terminal.

brew install mpv

MPV es un reproductor que funciona a través de la consola. Si lo que quieres es una interfaz gráfica, puedes utilizar IINA. Esta aplicación utiliza MPV como reproductor, dotándolo de una interfaz gráfica más amigable.

Con Python podemos exprimir las grandes características que nos ofrece MPV, ejecutando scrips que reproduzcan listas de video, todos los videos de una o varias carpetas, reproducir trozos aleatorios de videos, con secuencias que comienzan y acaban de forma aleatoria.

Este es el código para reproducir un archivo de video:

from subprocess import call

def reproduce(archivo, comienzo, resolucion, final):
    try:
        call('mpv "' +  archivo + '" – start=' + comienzo + ' – geometry=' + resolucion + ' – length=' + final, shell = True)
    except:
        print("Error al Reproducir Momento")

archivo = "" # Ruta del archivo
comienzo = "00:00:00"
resolucion = "45%"
final = "2:00:00"

reproduce(archivo, comienzo, resolucion, final)

Los parámetros que necesitamos pasar a la función son:

  • Archivo. La ruta del archivo que vamos a reproducir.
  • Comienzo. Donde empieza a reproducirse el archivo. Si queremos que empiece en el minuto 5, le pasamos 00:05:00
  • Resolución. El tamaño que tendrá la ventana de reproducción.
  • Final. El punto en el que se detendrá la reproducción, contando desde el momento que comienza la reproducción. En otras palabras, si la reproducción comienza en el minuto 5 (00:05:00), y queremos reproducir 15 segundos (00:00:15), la reproducción se detendrá en el minuto 5:15

Para listar todos los subdirectorios de una carpeta, devuelve los archivos contenidos en todas las subcarpetas encontradas.

from os.path import isfile, isdir, join

def listdir_recurd(files_list, root, folder, checked_folders):

    if (folder != root):
        checked_folders.append(folder)
        
    for f in listdir(folder):
        d = join(folder, f)       

        if isdir(d) and d not in checked_folders:
            listdir_recurd(files_list, root, d, checked_folders)
        else:
            if isfile(d):  # si no hago esto, inserta en la lista el nombre de las carpetas ignoradas
                files_list.append(join(folder, f))

    return files_list

Para obtener un tiempo aleatorio.

import random

def tiempo_aleatorio(tMin, tSeg):
    minutos = random.randint(0, tMin)
    segundos = random.randint(0, tSeg)

    tiempo = "00:%s:%s" %(minutos, segundos)
    return tiempo

Obtener la duración de un video, para ello debemos tener instalada la aplicación exiftool. Sabiendo la duración del video, calculamos un punto de inicio y fin aleatorio, sin exceder la duración real del video.

import subprocess

def duracion_escena(escena):
    datos = subprocess.check_output(['exiftool', escena]).decode('utf-8')

    dic = {}
    for line in datos.splitlines():
        valores = line.split(" : ",1)
        dic[valores[0].strip()] = valores[1].strip()

    duracion = dic['Track Duration']

    dura = duracion.split(":")
    minutos = int(dura[0]) + int(dura[1])

    resultado = tiempo_aleatorio(minutos, 59)

    return resultado

Desordenar una lista obtenida con la función anterior listdir_recurd.

import random

def random_sin_repetir(lista):
    for _ in range(0,len(lista)):
        result = random.choice(lista)
        yield result
        lista.remove(result)

El reproductor MPV dispone de infinidad de parametros para controlar la reproducción de videos, puedes ver más información aqui.

Share

Conocer las tarifas de luz cada hora, script en python

Las tarifas de luz son cada día más caras, por lo que tenemos que mirar muy bien cuándo realizamos nuestros consumos. Es cierto que muchos electrodomésticos no se pueden desconectar, como es la nevera, pero por ejemplo la lavadora, secadora o secador de pelo, podemos y debemos utilizarlos entre los rangos de horas que la electricidad es más barata.

Para las tarifas (PVPC) Precios Voluntarios para el Pequeño Consumidor.

Según la tarifa de luz eléctrica que tengamos contratada, el precio de la luz en cada zona horario es diferente.

Con la tarifa 2.0.A, el precio de la luz por horas es bastante uniforme, variando entre la hora más barata a la más cara un 14%, el precio de la hora más barata se sitúa en torno a los 0,095 € y la más cara a 0,110 €.

La tarifa 2.0.DHA, con dos discriminaciones horarias, divide el día en dos franjas, de 10 de la noche a las 12 del medio día del día siguiente, esta es la tarifa con las horas más baratas, en torno a los 0,05 €, recuerda que cada hora varia el precio. Y la franja de 12 del mediodía a 10 de la noche el precio por hora oscila entre los 0,12 €. La diferencia entre las horas baratas y las horas caras es de un 175%. Si tu consumo se realiza principalmente entre la franja con las horas más baratas, es muy recomendable utilizar esta tarifa.

La tarifa 2.0.DHS es muy similar a la tarifa 2.0.DHA, esta indicada para la carga de vehículos eléctricos. Las horas nocturnas son un poco más baratas que en la tarifa anterior.

Los valores indicados son los precios oficiales, y están referidos al Término de Facturación de Energía Activa del PVPC, de la Tarifa general (2.0.A), Tarifa discriminación horaria también llamada tarifa nocturna (2.0.DHA), y Vehículo eléctrico (2.0.DHS). 

Para obtener el precio real de la electricidad en cada franja horaria disponemos de la API de esios.

Los códigos de la api para cada una de las tarifas son:

  • 2.0.A – 10229
  • 2.0.DHA – 10230
  • 2.0.DHS – 10231

Para poder utilizar la API de esios, debemos utilizar un TOKEN. Este TOKEN debemos solicitarlo en la siguiente dirección de correo, consultasios@ree.es.

El código Python:

import requests
import json

TOKEN = "poner aqui el token"


url = 'https://api.esios.ree.es/indicators/10230'
headers = {'Accept':'application/json; application/vnd.esios-api-v2+json','Content-Type':'application/json','Host':'api.esios.ree.es','Authorization':'Token token=' + TOKEN}

response = requests.get(url, headers=headers)

if response.status_code == 200:
    json_data = json.loads(response.text)

    valores = json_data['indicator']['values']

    precios = [x['value'] for x in valores]
    
    hora = 0
    for precio in precios:
        print("%s horas - %s €" %(str(hora).zfill(2), str(round(precio/1000, 4))))
        hora += 1

    
    valor_min = min(precios)
    valor_max = max(precios)
    valor_med = round(statistics.mean(precios),2)
    
    print("Precio mínimo: %s" % str(valor_min/1000))
    print("Precio máximo: %s" % str(valor_max/1000))
    print("Precio medio: %s" % str(valor_med/1000))

El código anterior descarga la tarifa 2.0.DHA (10230). Cambiando el parametro de la url, despues de indicators, el código corresponde a la tarifa que queremos consultar.

Se obtiene el precio de cada fracción de hora, la hora y el precio mínimo, máximo, y el valor medio.

Resultado:

00 horas - 0.0547 €
01 horas - 0.0435 €
02 horas - 0.0471 €
03 horas - 0.0459 €
04 horas - 0.044 €
05 horas - 0.0434 €
06 horas - 0.0465 €
07 horas - 0.0615 €
08 horas - 0.0588 €
09 horas - 0.0545 €
10 horas - 0.0524 €
11 horas - 0.0571 €
12 horas - 0.0574 €
13 horas - 0.1209 €
14 horas - 0.1207 €
15 horas - 0.1213 €
16 horas - 0.1205 €
17 horas - 0.1227 €
18 horas - 0.1274 €
19 horas - 0.1253 €
20 horas - 0.1237 €
21 horas - 0.1238 €
22 horas - 0.1202 €
23 horas - 0.0519 €
Precio mínimo: 0.04344
Precio máximo: 0.12742
Precio medio: 0.08105

Share

Postgresql. Transformar los datos de columnas en filas.

Puede ocurrir que en algunas situaciones necesitemos obtener los datos de las columnas de una tabla en Postgres para que dicha información sea mostrada en filas.

Para ver el funcionamiento de este tipo de consultas vamos a crear una tabla con los primeros 6 meses del año. Utilizamos dos filas de datos obtenidos de forma aleatoria.

Creamos la tabla.

DROP TABLE IF EXISTS "public"."ventas";
CREATE TABLE "public"."ventas" (
  "id" int2 NOT NULL DEFAULT nextval('venta_id_seq'::regclass),
  "enero" int2,
  "febrero" int2,
  "marzo" int2,
  "abril" int2,
  "mayo" int2,
  "junio" int2
);
ALTER TABLE "public"."ventas" ADD CONSTRAINT "venta_pkey" PRIMARY KEY ("id");

Insertamos los datos aleatorios.

INSERT INTO "public"."ventas" VALUES (1, 400, 45, 234, 120, 112, 80);
INSERT INTO "public"."ventas" VALUES (2, 345, 90, 198, 98, 145, 144);

La siguiente consulta muestra los datos de las columnas en filas.

select id, 
unnest(array[enero, febrero, marzo, abril, mayo, junio]) AS importe,
unnest(array['Enero', 'Febrero', 'Marzo', 'Abril','Mayo','Junio']) AS meses											
FROM ventas 
group by id
order by id
idImporteMes
1400Enero
145Febreo
1234Marzo
1120Abril
1112Mayo
180Junio
2345Enero
290Febreo
2198Marzo
298Abril
2145Mayo
2144Junio

Con una consulta normal los datos se verán asi.

idEneroFebreroMarzoAbrilMayoJunio
14004523412011280
23459019898145144

Con la función “unnest” de postgres, y un par de arrays, conseguimos mostrar la información de cada una de las columnas de una tabla en una fila independiente. El segundo array que utilizamos es solo para mostrar en la fila el nombre de la columna correspondiente.

Este truco nos puede resultar muy útil cuando necesitamos mostrar los datos de una sola fila, en una tabla con muchas columnas, en vez de mostrar los datos en una extensa linea, podemos dividir cada columna en su correspondiente fila, mostrando la información de una forma más clara.

Share

17 trucos para Python

Sin lugar a dudas Python se ha convertido en el lenguaje más versátil de la última decada.

Es posible utilizarlo para multitud de propósitos; realizar scripts de mantenimiento, crear sofisticadas paginas web, aprendizaje automático (Machine Learning), desarrollo de aplicaciones de escritorio, análisis de datos, juegos, entre otras muchas más.

Y ademas es multi-plataforma, se puede utilizar en Windows, Mac, Linux y dispositivos móviles iOS y Android.

Os traemos 17 útiles trucos para Python:

Generar UUID. Los UUID son identificadores únicos universales compuesto de 32 dígitos hexadecimales, formando 5 grupos separados por guiones, 8-4-4-4-12.

import uuid
nuevo_id = uuid.uuid4()

Ver listas, diccionarios y sobre todo json con más claridad. Para ello utilizamos la función pprint.

import requests
import pprint

url = "https://randomuser.me/api/?results=1"
users = requests.get(url).json()

pprint.pprint(users)

Crea una sola cadena a partir de todos los elementos de una lista.

a = ["Python", "es", "el", "mejor"]
print(" ".join(a))

Listar los archivos de un directorio, sin mostrar los ocultos.

import os

def ls2(path): 
    return [obj.name for obj in os.scandir(path) if obj.is_file() and not obj.name.startswith('.')]

Mover archivos entre carpetas.

import shutil

shutil.move(archivo_origen, archivo_destino)

Iniciar un servidor estático en directorio local.

# En Mac y Linux 
python -m SimpleHTTPServer

# Windows 
python -m http.server

Mostar notificaciones en Mac.

import os

def notify(title, text):
    os.system("""
              osascript -e 'display notification "{}" with title "{}"'
              """.format(text, title))

Explorar las librerías. Muestra un listado con las funciones que contienen.

import requests
import collections

dir(requests)
dir(collections)

Valor por defecto en diccionario, si no existe la clave.

nombres = {1:'Casa', 2:'Patio', 3:'Jardin', 4:'Terraza'}
def  control(code):
    #return 'Zona: %s!' % nombres[code] #Expresión normal
    return 'Zona: %s!' % nombres.get(code, 'El lugar no exite')

print(control(5))

Sumar minutos a una hora.

from datetime import datetime, date, time, timedelta

ahora = datetime.now()
hora_actual = time(ahora.hour, ahora.minute, ahora.second)
minutos = (datetime.combine(datetime.date(ahora), hora_actual) + timedelta(minutes = 30)).time()

print(minutos)

Sumar dias a una fecha.

from datetime import datetime, date, time, timedelta

ahora = datetime.now()
nuevaFecha = ahora.date() + timedelta(days = 10)

print(nuevaFecha)

Evitar la salida de datos en Jupyter Notebook.

%%capture

a = ["Python", "es", "el", "mejor"]
print(" ".join(a))

Eliminar carácteres no alfanumericos.

import re

s = "La casa tiene && $$ %% Goteras de Caballo"
s = re.sub('[^0-9a-zA-Z]+', ' ', s)

print(s)

Reimportar modulo.

reload(modulo)

Emojis. Emojis con caracteres Unicode.

print(chr(128513))

Crea un diccionario a partir de 2 listas.

keys = ["a", "b", "c", "d", "e"]
valores = [1,2,3,4,5]

zipped = dict(zip(keys, valores))

print(zipped)

Ocultar el password al pedirlo por consola.

import getpass
usuario = raw_input("Introduce usuario: ")
password = getpass.getpass("Introduce password: ")
print(usuario, password)

Share

Gráficas utilizando CanvasJS

Las gráficas nos ayudan a visualizar un conjunto de datos para que podamos comparar rápidamente sus valores. 

Una tabla de datos en una hoja puede resultar difícil de analizar y tardaremos más tiempo en comprender y comparar los valores. En una gráfica todo se ve mucho más claro solo con un vistazo.

Aquí podemos ver un simple ejemplo para la creación de gráficas utilizando la librería CanvasJS.

Con esta librería podemos crear rápidamente gráficas dinámicas e integrarlas en la web.

Código html:

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css"/>
    
    <title>Ejemplos Graficas</title>
</head>
<body>
    <div class="container-fluid">
        <div class="row">
            <div class="col-md-6">
            <div id="pieChart" style="height: 360px; width: 100%;">
            </div>
            </div>
            <div class="col-md-6">
            <div id="columnChart" style="height: 360px; width: 100%;">
            </div>
            </div>
        </div>
        </div>

    <script src="https://canvasjs.com/assets/script/canvasjs.min.js"> </script>
    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js"></script>
    <script src="pack.js"></script>
</body>
</html>

Código javaScript:

var pieChartValues = [{
    y: 39.16,
    exploded: true,
    indexLabel: "Estados Unidos",
    color: "#1f77b4"
}, {
    y: 21.8,
    indexLabel: "Canada",
    color: "#ff7f0e"
}, {
    y: 21.45,
    indexLabel: "Europa",
    color: " #ffbb78"
}, {
    y: 5.56,
    indexLabel: "Malasia",
    color: "#d62728"
}, {
    y: 5.38,
    indexLabel: "Peru",
    color: "#98df8a"
}, {
    y: 3.73,
    indexLabel: "Bolivia",
    color: "#bcbd22"
}, {
    y: 2.92,
    indexLabel: "Tunez",
    color: "#f7b6d2"
}];
renderPieChart(pieChartValues);

function renderPieChart(values) {

    var chart = new CanvasJS.Chart("pieChart", {
        backgroundColor: "white",
        colorSet: "colorSet2",

        title: {
            text: "Pie Chart",
            fontFamily: "Verdana",
            fontSize: 25,
            fontWeight: "normal",
        },
        animationEnabled: true,
        data: [{
            indexLabelFontSize: 15,
            indexLabelFontFamily: "Monospace",
            indexLabelFontColor: "darkgrey",
            indexLabelLineColor: "darkgrey",
            indexLabelPlacement: "outside",
            type: "pie",
            showInLegend: false,
            toolTipContent: "<strong>#percent%</strong>",
            dataPoints: values
        }]
    });
    chart.render();
}
var columnChartValues = [{
    y: 936.04,
    label: "Paris",
    color: "#1f77b4"
}, {
    y: 391.84,
    label: "Londres",
    color: "#ff7f0e"
}, {
    y: 365.76,
    label: "Roma",
    color: " #ffbb78"
}, {
    y: 197.48,
    label: "Barcelona",
    color: "#d62728"
}, {
    y: 94.2,
    label: "Atenas",
    color: "#98df8a"
}, {
    y: 65.28,
    label: "Berlin",
    color: "#bcbd22"
}, {
    y: 51.2,
    label: "Madrid",
    color: "#f7b6d2"
}];
renderColumnChart(columnChartValues);

function renderColumnChart(values) {

    var chart = new CanvasJS.Chart("columnChart", {
        backgroundColor: "white",
        colorSet: "colorSet3",
        title: {
            text: "Datos por Ciudades",
            fontFamily: "Verdana",
            fontSize: 25,
            fontWeight: "normal",
        },
        animationEnabled: true,
        legend: {
            verticalAlign: "bottom",
            horizontalAlign: "center"
        },
        theme: "theme2",
        data: [

            {
                indexLabelFontSize: 15,
                indexLabelFontFamily: "Monospace",
                indexLabelFontColor: "darkgrey",
                indexLabelLineColor: "darkgrey",
                indexLabelPlacement: "outside",
                type: "column",
                showInLegend: false,
                legendMarkerColor: "grey",
                dataPoints: values
            }
        ]
    });

    chart.render();
}

Son dos ejemplos simples para ver el potencial que nos ofrece esta librería.

Puedes encontar más información aquí.

Share