def get(self, id):
if self.user:
movie = Films.query(Films.api_id == id).get()
if movie is None:
return webapp2.abort(404)
cid = self.request.get('cinema')
cinema = Cinemas.get_by_api_id(cid)
cname = None
film_times = None
if cinema:
cname = cinema.name
film_times = Cinemas.get_film_times_cinema(cinema, movie)
template_values = {
'localUser': "******" + self.user.name,
'movie':movie,
'mt':movie.title,
'cinema_name': cname,
'film_times': film_times,
}
self.render_template('movie.html', params=template_values)
else:
self.redirect(self.uri_for('login'))
def get(self):
if self.user:
latest_films = Films.query().order(-Films.release).fetch(12)
template_values = {
'news':latest_films,
'localUser': "******" + self.user.name
}
self.render_template('home.html', params=template_values)
else:
self.redirect(self.uri_for('login'))
def scrape_film_titles_and_hrefs(self, latest_year, earliest_year):
for year in range(latest_year, earliest_year - 1, -1):
print("\nCollecting data for {} films\n".format(year))
url = "https://en.wikipedia.org/wiki/{}_in_film".format(year)
r = requests.get(url)
html = BeautifulSoup(r.text, "lxml")
tables = html.find_all("table", attrs={"class":"wikitable"})
for table in tables:
# film release tables start with "Opening" column
if table.find("th").text.strip() == "Opening":
n_cols = len(table.find("tr").find_all('th'))
# every row in the table body is a released film
for row in table.find("tbody").find_all("tr"):
row_data = row.find_all("td")
try:
if len(row_data) == n_cols:
film = row_data[1]
title = film.text.strip()
elif len(row_data) == n_cols - 1:
film = row_data[0]
title = film.text.strip()
try:
exists = self.session.query(Films).\
filter_by(title=title).one()
if exists:
continue
except NoResultFound:
try:
href = film.find('a')['href']
except TypeError:
href = None
film_obj = Films(
title = title,
wiki_href = href
)
self.session.add(film_obj)
self.session.commit()
print("Collected data for {}".\
format(film_obj.title))
except Exception as e:
print(e)
self.session.rollback()
def filtr(dataset):
dat = []
all_users = {}
# load films from db
films = {}
count = Films.select().count()
for i in range(0, count, 500):
data = Films.select().order_by(
Films.id).offset(i).limit(500).execute()
for d in data:
films[d.film_id] = model_to_dict(d)
# load users from db
count = Users.select().count()
users = {}
for i in range(0, count, 200):
data = Users.select().order_by(
Users.id).offset(i).limit(200).execute()
for d in data:
users[d.user_id] = model_to_dict(d)
# preparing dataset
for d in dataset:
limit = 100
res = {}
uid = d["user_value"]["tel_id"] if "tel_id" in d[
"user_value"] else d["user_value"]["user_id"]
if uid in all_users:
all_users[uid] += 1
if all_users[uid] > limit:
continue
else:
all_users[uid] = 1
res["user"] = users[uid]
res["film"] = films[d["film_value"]["film_id"]]
res["result"] = d["result"]
dat.append(res)
return dat
def test_post(self):
u = Users.get()
f = Films.get()
r = requests.post('http://localhost:9091/mark',
json={
"user_id": u.user_id,
"film_id": f.film_id,
"result": 1,
})
self.assertEqual(r.text, "ok")
r = requests.post('http://localhost:9091/mark',
json={
"film_id": f.film_id,
"event": "trailer",
})
self.assertEqual(r.text, "ok")
def user_preparation(self, data: dict):
"""
Transform the model into a feature vector for learning
:param <User_fp.Model> as json:
:return list of Int:
"""
data = data.copy()
del data["group"]
del data["just_marked"]
del data["predict_films"]
del data["user_id"]
del data["id"]
msex = 0
mage = 0
myers = 0
liked_films = Films.select().where(
Films.film_id.in_(data["liked"] + data["viewed"])).execute()
for f in liked_films:
msex += f.sex
mage += f.meanage
myers += 2019 - f.year
data["myers"] = myers / (len(liked_films) + 1)
data["mage"] = mage / (len(liked_films) + 1)
data["msex"] = msex / (len(liked_films) + 1)
del data["viewed"]
del data["disliked"]
del data["liked"]
vb = data["ganres"] + data["liked_vector"]
del data["ganres"]
del data["liked_vector"]
del data["disliked_vector"]
res = list(OrderedDict(data).values()) + vb
return res
def grupocine(self):
try:
page = "http://www.grupocine.com.uy/categoria_15_1.html"
sock = urllib.urlopen(page)
htmlSource = sock.read()
sock.close()
soup = BeautifulSoup(htmlSource, "html.parser")
image = soup.find_all('img', src=re.compile("imgnoticias"))
title = (soup.find_all(attrs={"class": "contenidoUCh3"}))
tittle = []
for i in title:
tittle.append(i.string)
shedule = soup.find_all(attrs={"class": "contenidoUCh4"})
description = soup.find_all(attrs={"class": "contenidoUCh5"})
f = []
for i, j, k, l in zip(tittle, shedule, description, image):
if False: #Films.query(Films.title == i.encode('utf8', 'replace')):
#edit = Films.query(Films.title == i.encode('utf8', 'replace'))
edit_key = (ndb.Key("Films",
i.encode('utf8',
'replace'))).urlsafe()
edit_key2 = Films.query(
Films.title == i.encode('utf8', 'replace'))
edit = edit_key2.get()
list_cine = edit.cine
edit.cine.append("life")
edit.put()
return edit
else: #f.append((i,j,k,l))
save = Films(title=i.encode('utf8', 'replace'),
shedule=str(j),
description=str(k),
image=str(l),
cine=["grupocine"])
save.put()
f = Films.query()
return f
except:
return traceback.format_exc()
def handle_films():
return jsonify(Films.getAllFilms()), 200
def new_film():
context = {'film': ''}
if request.method == "GET":
session = Session(engine)
genres = session.query(Genres).all()
context = {'genres': genres, 'film': ''}
session.close()
# TODO: Make bleach check
if request.method == 'POST':
form = request.form
print(request.files)
if 'poster' not in request.files:
flash('Постер не загружен')
return redirect(request.url)
file = request.files['poster']
if file.filename == '':
flash('Файл не выбран')
return redirect(request.url)
if file and allowed_file(file.filename):
session = Session(engine)
mime_type = file.content_type
# Add random string to file, to prevent russian letters corrupt by secure_filename
file_name = str(random.randint(10000, 99999)) + secure_filename(
file.filename)
path = os.path.join(app.config['UPLOAD_FOLDER'], file_name)
file.save(path)
with open(path, 'rb') as f:
md5_hash = hashlib.md5(f.read()).hexdigest()
poster = session.query(Posters).filter(
Posters.md5_hash == md5_hash)
poster_id = 0
# FIXME: !!! FILE IS EMPTY AFTER WRITE !!! Fixed.
# Duplicate posters check
if len(poster.all()):
poster_id = poster.first().id
print('{}: poster exists'.format(poster_id))
print(poster_id)
# Remove file if exists
os.remove(path)
else:
new_poster = Posters(file_name=file_name,
mime_type=mime_type,
md5_hash=md5_hash)
session.add(new_poster)
session.commit()
poster_id = new_poster.id
session.close()
session = Session(engine)
new_film = Films(name=form['name'],
year=form['year'],
country=form['country'],
director=form['director'],
screenwriter=form['screenwriter'],
actors=form['actors'],
length=form['length'],
description=form['description'],
poster_id=poster_id)
session.add(new_film)
session.commit()
film = new_film.id
session.close()
if form.getlist('genres'):
for genre in form.getlist('genres'):
query = 'INSERT INTO film_genres (film_id, genre_id) VALUES (%s, %s);'
cursor = mysql.connection.cursor(named_tuple=True)
cursor.execute(query, (film, genre))
mysql.connection.commit()
cursor.close()
# TODO: Don't forget about genres manytomany fix
return render_template('films/new.html', context=context)
import requests
from models import Users, Films
u = Users.get()
f = Films.get()
r = requests.post('http://localhost:9091/mark',
json={
"user_id": u.user_id,
"film_id": f.film_id,
"result": 1,
})
import requests
from bs4 import BeautifulSoup
from models import Films
for i in range(1, 966):
if i == 1:
par = requests.get('http://bestofkinopoisk.com/')
par = requests.get('http://bestofkinopoisk.com/page/{}'.format(i))
soup = BeautifulSoup(par.text, 'html.parser')
for tags in soup.find_all('div', class_='b-content__inline_item-link'):
if tags.div.attrs:
continue
else:
info = tags.div.string.split(',')
while len(info) < 3:
info.insert(1, 'None')
print(info)
tl = tags.a.string
film = Films(title=tl,
years=info[0],
country=info[1],
genre=info[2])
film.save()
def test_get_film_marks(self):
u = Users.get()
films = Films.select().limit(5).execute()
films = [model_to_dict(f) for f in films]
res = self.fm.get_film_marks(model_to_dict(u), films)
self.assertEqual(len(films), len(res))
def test_lite_data(self):
u = Users.get()
f = Films.get()
res = self.fm.lite_data(model_to_dict(f), model_to_dict(u))
self.assertIsInstance(res, list)
self.assertIsInstance(res[0], float)