358 lines
11 KiB
Python
358 lines
11 KiB
Python
import requests
|
|
import shutil
|
|
import random
|
|
import time
|
|
import wikipediaapi
|
|
from bs4 import BeautifulSoup
|
|
from django.conf import settings
|
|
from django.db import models
|
|
from pathlib import Path
|
|
|
|
|
|
class Gender(models.Model):
|
|
id = models.AutoField(primary_key=True)
|
|
name = models.CharField(max_length=250)
|
|
|
|
class Meta:
|
|
unique_together = ["name"]
|
|
ordering = ["name"]
|
|
verbose_name = "Género"
|
|
verbose_name_plural = "Generos"
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class Country(models.Model):
|
|
id = models.AutoField(primary_key=True)
|
|
name = models.CharField(max_length=250, verbose_name="País")
|
|
|
|
class Meta:
|
|
unique_together = ["name"]
|
|
ordering = ["name"]
|
|
verbose_name = "País"
|
|
verbose_name_plural = "Paises"
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class PersonQuerySet(models.QuerySet):
|
|
def directors(self):
|
|
rows = self.filter(is_director=True).values_list("name", flat=True)
|
|
return rows
|
|
|
|
def actors(self):
|
|
rows = self.filter(is_actor=True).values_list("name", flat=True)
|
|
return rows
|
|
|
|
|
|
class Person(models.Model):
|
|
id = models.AutoField(primary_key=True)
|
|
name = models.CharField("Nombre", max_length=500)
|
|
country = models.ForeignKey(
|
|
Country, related_name="country", on_delete=models.PROTECT
|
|
)
|
|
date_born = models.DateField("Fecha de nacimiento", null=True, blank=True)
|
|
is_actor = models.BooleanField("Es Actor", default=False)
|
|
is_director = models.BooleanField("Es Director", default=False)
|
|
is_woman = models.BooleanField("Es mujer", default=False)
|
|
photo = models.ImageField(
|
|
"Fotografía", upload_to="%Y/%m/%d/", null=True, blank=True
|
|
)
|
|
objects = PersonQuerySet.as_manager()
|
|
|
|
class Meta:
|
|
unique_together = ["name"]
|
|
ordering = ["name"]
|
|
verbose_name = "Persona"
|
|
verbose_name_plural = "Personas"
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class MovieQuerySet(models.QuerySet):
|
|
def random_pick(self, random_max=6, min_items=20, **kwargs):
|
|
"""
|
|
Regresa películas de manera aleatoria.
|
|
|
|
Por defecto tiene que haber al menos 20 películas en la consulta.
|
|
Por defecto regresa un máximo de 6 películas.
|
|
"""
|
|
all = list(Movie.objects.filter(**kwargs).values())
|
|
if len(all) < min_items:
|
|
return None
|
|
elif len(all) < random_max:
|
|
return all
|
|
else:
|
|
return random.sample(all, random_max)
|
|
|
|
def top_pick(self, key, top_max=6):
|
|
"""
|
|
Regresa el top de películas.
|
|
|
|
El top corresponde al criterio de búsqueda en 'key'.
|
|
Por defecto regresa las primeras 6 películas como máximo.
|
|
"""
|
|
all = list(Movie.objects.order_by(f"-{key}").values())
|
|
return all[:top_max]
|
|
|
|
def top_random_pick(self, key, top_max=6):
|
|
"""
|
|
Regresa el top de películas de manera aleatorias.
|
|
|
|
El top corresponde al criterio de búsqueda en 'key'.
|
|
Por defecto regresa un máximo de 6 películas.
|
|
A diferencia de 'random_pick', de todo el top selecciona de manera
|
|
aleatoria según el 'top_max'.
|
|
"""
|
|
all = list(Movie.objects.order_by(f"-{key}").values())
|
|
top = []
|
|
for movie in all:
|
|
if movie[key] == all[0][key]:
|
|
top.append(movie)
|
|
else:
|
|
break
|
|
if len(top) > top_max:
|
|
return random.sample(top, top_max)
|
|
else:
|
|
return top
|
|
|
|
def home_pick(self):
|
|
"""
|
|
Regresa la selección de películas para el 'home'.
|
|
|
|
El 'home' es la página principal.
|
|
"""
|
|
genders = list(Gender.objects.values_list("id", flat=True))
|
|
sections = self.home_sections()
|
|
for gender in genders:
|
|
key = Gender.objects.get(pk=gender).name
|
|
picked = self.random_pick(genders=gender)
|
|
if picked:
|
|
sections["genders"][key] = self.fix_all_data(picked)
|
|
return sections
|
|
|
|
def home_sections(self):
|
|
"""
|
|
Regresa la selección de películas en secciones para el 'home'.
|
|
|
|
Las secciones son novedades, mejor valorados y más descargados.
|
|
"""
|
|
sections = {
|
|
"Novedades": self.fix_all_data(self.top_pick("id")),
|
|
"Mejor valorados": self.fix_all_data(self.top_random_pick("stars")),
|
|
"Más descargados": self.fix_all_data(self.top_pick("count")),
|
|
}
|
|
sections["genders"] = {}
|
|
return sections
|
|
|
|
def fix_all_data(self, movies):
|
|
"""
|
|
Enmienda los datos de las películas.
|
|
"""
|
|
for movie in movies:
|
|
self.fix_data(movie, wikipedia=False)
|
|
return movies
|
|
|
|
def fix_data(self, movie, wikipedia=True):
|
|
"""
|
|
Enmienda los datos de una película.
|
|
|
|
Los enmiendos son formateos de unos valores (que se guardan en nuevas
|
|
llaves) y de rutas a medios.
|
|
"""
|
|
movie["duration_formatted"] = self.format_duration(movie["duration"])
|
|
movie["count_formatted"] = self.format_count(movie["count"])
|
|
movie["stars_icons"] = self.format_stars(movie["stars"])
|
|
movie["file_name"] = self.fix_path(movie["file_name"])
|
|
movie["cartel"] = self.fix_path(movie["cartel"])
|
|
if wikipedia:
|
|
movie["wiki"] = self.get_wiki(movie)
|
|
|
|
def fix_path(self, el):
|
|
"""
|
|
Enmienda ruta a medio.
|
|
|
|
La ruta es distinta según se esté en producción o en desarrollo
|
|
('DEBUG').
|
|
"""
|
|
if settings.DEBUG:
|
|
return settings.URL_DEBUG.format(el)
|
|
else:
|
|
return settings.MEDIA_ROOT / el
|
|
|
|
def fix_summ(self, raw):
|
|
"""
|
|
Enmienda sinopsis de Wikipedia.
|
|
|
|
Los sumarios de artículos a la Wikipedia vienen con notas al pie que no
|
|
son necesarias. Para la sinopsis estas notas son eliminadas y se regresa
|
|
el código HTML como una cadena de caracteres.
|
|
"""
|
|
html = BeautifulSoup(raw, "lxml")
|
|
for ref in html.find_all("sup", "reference"):
|
|
ref.decompose()
|
|
clean = list(map(lambda x: str(x), html.body.children))
|
|
return " ".join(clean)
|
|
|
|
def format_stars(self, num):
|
|
"""
|
|
Da formato a la cantidad de estrellas.
|
|
|
|
Regresa la cantidad de estrellas en lugar del número de estas.
|
|
"""
|
|
stars = "★" * num
|
|
while len(stars) < 5:
|
|
stars += "☆"
|
|
return stars
|
|
|
|
def format_count(self, num):
|
|
"""
|
|
Da formato a la cantidad de descargas.
|
|
|
|
Regresa la cantidad en una cifra separada por comas.
|
|
"""
|
|
return "{:,}".format(num)
|
|
|
|
def format_duration(self, num):
|
|
"""
|
|
Da formato a duración.
|
|
|
|
Regresa la duración en horas:minutos.
|
|
"""
|
|
secs = num * 60
|
|
return time.strftime("%H:%M", time.gmtime(secs))
|
|
|
|
def get_wiki(self, movie, again=True):
|
|
"""
|
|
Obtiene artículo de Wikipedia.
|
|
|
|
Primero intenta obtener el artículo por el nombre original. Si no tiene
|
|
éxito, intenta obtenerlo por el nombre en español. Regresa None si no
|
|
tuvo ningún éxito.
|
|
"""
|
|
wiki = self.get_wiki_page(movie["original_name"])
|
|
if not wiki:
|
|
wiki = self.get_wiki_page(movie["name"])
|
|
return wiki
|
|
|
|
def get_wiki_page(self, title):
|
|
"""
|
|
Intenta obtener artículo de Wikipedia.
|
|
|
|
Si no tiene éxito, regresa 'None'.
|
|
"""
|
|
try:
|
|
lang = settings.LANGUAGE_CODE.split("-")[0]
|
|
wiki = wikipediaapi.Wikipedia(
|
|
lang, extract_format=wikipediaapi.ExtractFormat.HTML
|
|
)
|
|
page = wiki.page(title)
|
|
if page.exists():
|
|
return {
|
|
"title": page.title,
|
|
"url": page.fullurl,
|
|
"summary": self.fix_summ(page.summary),
|
|
}
|
|
else:
|
|
return None
|
|
except:
|
|
return None
|
|
|
|
def get_movie_by_id(self, id):
|
|
"""
|
|
Obtiene película por id.
|
|
|
|
Esta obtención también añade objetos relacionados.
|
|
"""
|
|
related = ["countries", "genders", "directors", "actors"]
|
|
movie = Movie.objects.prefetch_related(*related).get(pk=id).__dict__
|
|
for key, val in movie['_prefetched_objects_cache'].items():
|
|
movie[key] = list(map(lambda x: x['name'], val.values()))
|
|
movie.pop("_state")
|
|
movie.pop("_prefetched_objects_cache")
|
|
self.fix_data(movie)
|
|
return movie
|
|
|
|
def get_movies(self, prefix, query):
|
|
"""
|
|
Obtiene películas buscadas.
|
|
|
|
El 'prefix' permite filtrar la consulta por el campo seleccionado.
|
|
"""
|
|
selector = self.get_movie_selector(prefix)
|
|
return f"selector: {selector}; query: {query}"
|
|
|
|
def get_movie_selector(self, prefix):
|
|
"""
|
|
Obtiene el selector para filtrar la consulta de una búsqueda.
|
|
|
|
Esto permite restricciones en la búsqueda con esta sintaxis:
|
|
* t:Un Título => Buscará las películas que tengan 'Un T…' en sus 'name'
|
|
* d:Nombre => Buscará las películas que tengan 'N…' en sus 'directors'
|
|
"""
|
|
prefixes = {
|
|
't': 'name',
|
|
'o': 'original_name',
|
|
'y': 'year',
|
|
'c': 'countries',
|
|
'p': 'countries',
|
|
'd': 'directors',
|
|
'a': 'actors',
|
|
'g': 'genders',
|
|
's': 'section',
|
|
}
|
|
if prefix in prefixes:
|
|
return prefixes[prefix]
|
|
else:
|
|
return ''
|
|
|
|
|
|
def upload_cartel(instance, filename):
|
|
first = filename[0].upper()
|
|
if first.isdigit():
|
|
first = "0"
|
|
return f"{first}/{filename}"
|
|
|
|
|
|
class Movie(models.Model):
|
|
id = models.AutoField(primary_key=True)
|
|
name = models.CharField("Nombre", max_length=1000)
|
|
original_name = models.CharField(
|
|
"Nombre original", max_length=1000, default="", blank=True
|
|
)
|
|
file_name = models.CharField(
|
|
"Nombre archivo", max_length=1000, default="", blank=True
|
|
)
|
|
year = models.PositiveSmallIntegerField("Año", default=1900)
|
|
duration = models.PositiveSmallIntegerField("Duración", default=0)
|
|
directors = models.ManyToManyField(
|
|
Person, verbose_name="Director", related_name="directors"
|
|
)
|
|
actors = models.ManyToManyField(Person, related_name="actors", blank=True)
|
|
countries = models.ManyToManyField(
|
|
Country, related_name="countries", verbose_name="País", blank=True
|
|
)
|
|
genders = models.ManyToManyField(
|
|
Gender, related_name="genders", verbose_name="Género", blank=True
|
|
)
|
|
cartel = models.ImageField(
|
|
"Cartel", upload_to=upload_cartel, null=True, blank=True
|
|
)
|
|
count = models.PositiveIntegerField("Descargas", default=0)
|
|
stars = models.PositiveSmallIntegerField("Estrellas", default=0)
|
|
published = models.BooleanField("¿Publicar?", default=True)
|
|
is_digital = models.BooleanField("Es digital", default=False)
|
|
objects = MovieQuerySet.as_manager()
|
|
|
|
class Meta:
|
|
unique_together = ["name", "original_name"]
|
|
ordering = ["name"]
|
|
verbose_name = "Película"
|
|
verbose_name_plural = "Películas"
|
|
|
|
def __str__(self):
|
|
return self.name
|