def parse_tweet_media(tweet: Tweet, extended_entities: list):
for entity in extended_entities['media']:
tweet.text = tweet.text.replace(entity['url'], '')
if 'video_info' in entity:
video_urls = entity['video_info']['variants']
video_url = max(
[video for video in video_urls if ('bitrate') in video],
key=lambda x: x['bitrate'])['url']
tweet.add_media(Media('video', video_url))
else:
photo_url = entity['media_url_https']
tweet.add_media(Media('photo', photo_url))
def parse_tweet_media(self, tweet: Tweet, extended_entities: list):
for entity in extended_entities.media:
tweet.text = tweet.text.replace(entity.url, '')
if 'video_info' in entity:
video_urls = entity.video_info.variants
video_url = max(
[video for video in video_urls if ('bitrate') in video],
key=lambda x: x.bitrate).url
tweet.media_list.append(Media('video', video_url))
self.logger.debug("- - Found video URL in tweet: " + video_url)
else:
photo_url = entity.media_url_https
tweet.media_list.append(Media('photo', photo_url))
self.logger.debug("- - Found photo URL in tweet: " + photo_url)
def post(self):
upload_files = self.get_uploads('gallery_images')
id = self.request.get("team_id")
team = Team.get_by_id(long(id))
redirect_url = self.uri_for('view-team', team_id = id )
logger.info('Uploaded files: ' + str(upload_files))
#logger.info('Get Request: ' + str(self.request.get()))
if upload_files is not None and len(upload_files) > 0:
files_count = len(upload_files)
logger.info('no of files uploaded ' + str(files_count))
for x in xrange(files_count):
blob_info = upload_files[x]
media_obj = Media()
#media_obj.name = self.form.media.__getitem__(x).data['name']
media_obj.type = constants.PHOTO
media_obj.status = True
#media_obj.primary = self.form.media.__getitem__(x).data['primary']
media_obj.link = blob_info.key()
media_obj.url = images.get_serving_url(blob_info.key())
media_obj.entity_id = team.key
media_obj.entity_type = constants.TEAM
logger.info('Upload file detail: ' + str(media_obj))
#self.mediaDao.persist(media_obj)
media_obj.put()
logger.info('Link to picture file ' + images.get_serving_url(media_obj.link))
return self.redirect(redirect_url)
def test_02_00(self):
dbsession = createdbsession('sqlite:///testdatabase.db',
sqlecho=False,
cleardown=True)
with open('testlocations.csv', mode='r') as fp:
csvreader = csv.reader(fp)
for data in csvreader:
add_location = Locations(locationid=data[0],
name=data[1],
description=data[2],
sublocation=data[3])
dbsession.add(add_location)
print data
with open('testmedia.csv', mode='r') as fp:
csvreader = csv.reader(fp)
for data in csvreader:
add_media = Media(mediaid=data[0],
mediatype=data[1],
title=data[2],
description=data[3],
url=data[4],
barcode=data[5],
locationid=data[6])
dbsession.add(add_media)
print data
dbsession.commit()
def index_content(root_dir, file_types, content_type):
""" Scan the media directory, creating an index of file properties for display and serving
"""
logger.debug('indexing')
hasher = sha1()
content_dir = os.path.join(root_dir, app.config['CONTENT_DIR'])
files = file_paths(filtered_walk(
content_dir,
included_files=file_types,
))
for contentfile in files:
rel_path = os.path.relpath(contentfile, root_dir)
filepath = os.path.join(root_dir, rel_path)
filename = os.path.split(contentfile)[1]
local_path = os.path.relpath(filepath, root_dir)
if os.path.exists(os.path.join(filepath, 'folder.jpg')):
img = os.path.join(filepath, 'folder.jpg')
else:
img = ''
hasher.update(local_path)
file_key = hasher.hexdigest()
tags = _get_tags(filepath)
media = Media()
media.type = content_type
media.path = filepath
media.filename = filename
media.file_id = file_key
media.tags = tags
media.img = img
media.type = content_type
media.save()
def setUp(self):
# set TEMPLATE_DEBUG to True to ensure {% include %} will raise
# exceptions since that is how inlines are rendered and #9498 will
# bubble up if it is an issue.
self.original_template_debug = settings.TEMPLATE_DEBUG
settings.TEMPLATE_DEBUG = True
self.client.login(username='******', password='******')
# Can't load content via a fixture (since the GenericForeignKey
# relies on content type IDs, which will vary depending on what
# other tests have been run), thus we do it here.
e = Episode.objects.create(name='This Week in Django')
self.episode_pk = e.pk
m = Media(content_object=e, url='http://example.com/podcast.mp3')
m.save()
self.mp3_media_pk = m.pk
m = Media(content_object=e, url='http://example.com/logo.png')
m.save()
self.png_media_pk = m.pk
def get_active_media(self, key, sport, type):
logger.info('NdbMediaDao:: DBHIT: get_active_media for %s ' % type)
media_query = Media.query(Media.entity_id == key,
Media.entity_type == type,
Media.status == True)
media = media_query.fetch()
if media is None or len(media) == 0:
default_pic_url = get_default_media(type, sport)
default_pic = Media()
default_pic.url = default_pic_url
media.append(default_pic)
return media
def medias(filename=None):
if request.method == "GET":
media = Media.get_media(filename=filename)
if not media:
abort(404)
return send_from_directory(current_app.config["UPLOAD_FOLDER"],
media.filename)
elif request.method == "POST":
f = request.files["files[]"]
if not f:
return
filename = f.filename
# save file to local folder, if file exists, delete it
filepath = os.path.join(current_app.config['UPLOAD_FOLDER'], filename)
if os.path.exists(filepath):
os.remove(filepath)
f.save(filepath)
filesize = os.stat(filepath).st_size
now = datetime.now()
# if file with same name exists, replace it
media = Media.get_one(Media.filename == filename)
if not media:
media = Media(filename=filename)
media.fileid = hashlib.sha256(filename.encode("utf-8")).hexdigest()
media.size = filesize
media.content_type = f.content_type
media.size = filesize
media.create_time = now
media.save()
return jsonify({"files": []})
elif request.method == "DELETE":
removelist = request.json
for eachfile in removelist:
fileid = eachfile["fileid"]
filename = eachfile["filename"]
onemedia = Media.get_one(Media.fileid == fileid)
if onemedia.filename != filename:
continue
# remove file from folder
try:
os.remove(
onemedia.filepath(current_app.config["UPLOAD_FOLDER"]))
except Exception:
pass
# remove file from database
onemedia.delete_instance()
return jsonify(success=True, message="success")
def populate_data_into_db(media_list):
for media in media_list:
new_media = Media(media_dict=media)
if Media.query.filter_by(name=new_media.name,
artist_id=new_media.artist_id).first():
continue # just in case you have same two media in db
if Artist.query.filter_by(id=new_media.artist_id).first() == None:
artist_dict = look_up_artist_info(new_media.artist_id)
new_artist = Artist(artist_dict=artist_dict)
new_artist.save_to_db(
) # you have to save artist first, before you save a new media
new_media.save_to_db()
print("* Finish populating the data.")
def upload_photos(self, photos):
upload_files = self.get_uploads()
if upload_files is not None and len(upload_files) > 0:
files_count = len(upload_files)
logger.info('no of files uploaded ' + str(files_count))
for x in xrange(files_count):
blob_info = upload_files[x]
media_obj = Media()
media_obj.name = self.form.media.__getitem__(x).data['name']
media_obj.status = self.form.media.__getitem__(
x).data['status']
media_obj.link = blob_info.key()
photos.append(media_obj)
logger.info('Link to picture file ' + media_obj.name + ', ' +
images.get_serving_url(media_obj.link))
return photos
def fetch_media(user_pks, api, session, force_update=False):
"""
Fetch the media for these user pk's and isnert them into the DB
:user_pks a list of instagram user primary keys
:api The isntagram API
:session the dbsession
:force_update if true the queries will overide previous user entries in the db to update them
:returns a list of media pk's
"""
logger.info("Fetching media")
pks = []
for user_pk in user_pks:
api.getUserFeed(user_pk)
media = api.LastJson["items"]
# The user likely has more photos but I am not sure they are relevant
# older photos leads to less currently relevant data
# is medium the singular? probably not...
for medium in media:
media_pk = medium["pk"]
pks.append(media_pk)
# make sure pk not in db
if session.query(Media).get(media_pk) != None and not force_update:
# we still want to check for comments at this point so
# append the pk anyway
continue
is_picture = True if medium['media_type'] == 1 else False
instagram_media = Media(media_id=media_pk,
instagram_user_id=user_pk,
is_picture=is_picture)
session.add(instagram_media)
logger.debug("Got media " + str(media_pk) + " for user " +
str(user_pk))
# can't make requests too fast
time.sleep(config.SLEEP_TIME)
session.commit()
session.commit()
logger.info("Gatered media committed to database")
return pks
def sign_up_view():
title = "Sign up page"
form = MediaSignUpForm()
"""
if form.media_name is not None:
return redirect(url_for('account_print.success_sign_up_view'))
"""
if request.method == 'POST':
name = form.media_name.data
type = form.media_type.data
email = form.media_email.data
if Media.query.filter_by(media_name=name).first() is not None:
message = "Media house already exists"
return render_template("accounts/sign_up_page.html",
title=title,
form=form,
message=message)
password = bcrypt.generate_password_hash(
form.media_password.data) #.decode('utf-8')
media = Media(media_name=name,
media_type=type,
media_email=email,
media_password=password)
db.session.add(media)
db.session.commit()
media_id = media.id
message = "Please confirm email to complete sign up "
link = '<html><head><title>C Email</title></head><body><a href="http://127.0.0.1:5000/accounts/email-confirmation/{}">Confirm</a></body></html>'.format(
str(media_id))
msg = Message(subject='Announcement Media confirmation',
sender=app.config.get("MAIL_USERNAME"),
recipients=[email],
body="Click here to confirm email {}".format(link))
mail.send(msg)
""""if (name or email or type) == None:
return return render_template("accounts/sign_up_page.html",title=title,form=form,error)"""
return render_template("accounts/sign_up_page.html",
title=title,
form=form,
message=message,
media_id=media_id)
else:
return render_template("accounts/sign_up_page.html",
title=title,
form=form)
def publish_items_db(media_items, lang, headers):
"""Publish all items but it check if the post exists,
in this case, it will update the post.
:param media_items: List of items to will publish
"""
"""Define all variables"""
"""Create session"""
_session = app.apps.get("db_sqlalchemy")()
"""For each novels do to the following"""
for _item in media_items:
_published_episodes = []
"""For each new episode do to the following"""
for _episode in _item['new_episodes']:
"""If the posts doesn't exists, create the post"""
"""Upload cover"""
_cover = images.upload_images_from_urls(
urls=[_episode['cover']],
# watermark_code=watermark_code
)
"""Get media type"""
media_type = media.get_media_type(_episode['media_type'])
"""Prepare all chapters"""
_media_db = Media(
media_id_reference=_episode['media_id'],
collection_id_reference=_episode['collection_id'],
number=_episode['episode_number'],
title=_episode['title'],
url=_episode['url'],
cover=_cover['data']['images'][-1]['link'],
serie=_item['serie'],
media_type=media_type,
status=constants.STATUS['initial'],
)
"""Save chapters in database"""
_session.add(_media_db)
_session.flush()
_published_episodes.append(_media_db.to_dict(), )
_item['published'] = _published_episodes
"""Save in database"""
_session.commit()
"""Close session"""
_session.close()
"""Return the posts list"""
return media_items
def import_csv():
with open('media_list.csv') as csvfile:
data = csv.reader(csvfile)
# display data in the console
for row in data:
print(row)
media_title = row[0]
media_type = row[1]
artist = row[2]
genre = row[3]
published_date = clean_date(row[4])
price = clean_price(row[5])
new_media = Media(Title=media_title, Type=media_type, Artist=artist, Genre=genre, Date=published_date, Price=price)
session.add(new_media)
session.commit()
def upload_photos(self, key):
upload_files = self.get_uploads()
if upload_files is not None and len(upload_files) > 0:
files_count = len(upload_files)
logger.info('no of files uploaded ' + str(files_count))
for x in xrange(files_count):
blob_info = upload_files[x]
media_obj = Media()
media_obj.name = self.form.media.__getitem__(x).data['name']
media_obj.type = constants.PHOTO
media_obj.status = self.form.media.__getitem__(x).data['status']
media_obj.primary = self.form.media.__getitem__(x).data['primary']
media_obj.link = blob_info.key()
media_obj.url = images.get_serving_url(blob_info.key())
media_obj.entity_id = key
media_obj.entity_type = constants.PLAYGROUND
self.mediaDao.persist(media_obj)
logger.info('Link to picture file ' + media_obj.name + ', ' + images.get_serving_url(media_obj.link))
def job_finished_cb(patero, job):
tmp = []
for filename in job['output']['files']:
copy_or_link(filename, common.output_dir)
os.unlink(filename)
tmp.append(
os.path.join(common.output_dir, os.path.basename(filename)))
job['output']['files'] = tmp
job.save()
# here tell Caspa the file is ready
media = Media()
for key in ['metadata', 'stat']:
media.update(job['output'][key])
media['_id'] = job['output']['checksum']
media['checksum'] = job['output']['checksum']
media['files'] = job['output']['files']
media['file'] = job['output']['transcoded']
media['stat'] = job['output']['stat']
media.save()
def getMedia(self, mediaMessageProtocolEntity, message):
media = Media(
type=MediaType.get_mediatype(mediaMessageProtocolEntity.getMediaType()),
preview=mediaMessageProtocolEntity.getPreview())
if mediaMessageProtocolEntity.getMediaType() in (
MediaMessageProtocolEntity.MEDIA_TYPE_IMAGE,
MediaMessageProtocolEntity.MEDIA_TYPE_AUDIO,
MediaMessageProtocolEntity.MEDIA_TYPE_VIDEO
):
self.setDownloadableMediaData(mediaMessageProtocolEntity, media)
media.encoding = mediaMessageProtocolEntity.encoding
if mediaMessageProtocolEntity.getMediaType() != MediaMessageProtocolEntity.MEDIA_TYPE_AUDIO:
message.content = mediaMessageProtocolEntity.getCaption()
elif mediaMessageProtocolEntity.getMediaType() == MediaMessageProtocolEntity.MEDIA_TYPE_LOCATION:
message.content = mediaMessageProtocolEntity.getLocationName()
self.setLocationMediaData(mediaMessageProtocolEntity, media)
elif mediaMessageProtocolEntity.getMediaType() == MediaMessageProtocolEntity.MEDIA_TYPE_VCARD:
message.content = mediaMessageProtocolEntity.getName()
self.setVCardMediaData(mediaMessageProtocolEntity, media)
return media
def app():
app_running = True
while app_running:
choice = menu()
if choice == '1':
# add book/media
title = input('Media Title: ')
media_type = input('Media Type: ')
author = input('Media Author: ')
genre = input('Genre: ')
date_error = True
while date_error:
date = input(
'Published Date: (Use Date Format: January 1, 2021 ): ')
date = clean_date(date)
if type(date) == datetime.date:
date_error = False
price_error = True
while price_error:
price = input('Price (Use Price format 22.99): £')
price = clean_price(price)
if type(price) == int:
price_error = False
# add data to db
new_media_add = Media(media_title=title,
media_type=media_type,
artist=author,
genre=genre,
published_date=date,
price=price)
session.add(new_media_add)
session.commit()
# print menu then pause before menu display
print("\n\n**Media Successfully Added! **")
time.sleep(1.3)
elif choice == '2':
# view book
for media in session.query(Media):
print(media)
# add print for genre
print(
f'{media.media_title} >> {media.media_type} >> {media.artist} >> {media.published_date} >> {media.price} ... \n'
)
input("\n Press Enter to return to the main menu")
elif choice == '3':
# option 3
id_options = []
for media in session.query(Media):
id_options.append(media.id)
id_error = True
while id_error:
id_choice = input(f'''
\nMedia ID Options: { id_options }
\rEnter Book id: ''')
id_choice = clean_id(id_choice, id_options)
if type(id_choice) == int:
id_error = False
# display_searched_book - a descriptive variable name that describes what it is storing
display_searched_book = session.query(Media).filter(
Media.id == id_choice).first()
#Formatted String to display media information
print(f'''
\n{display_searched_book.media_title} by {display_searched_book.artist}
\nFormatted String
\n P: £{ display_searched_book.price / 100 }''')
# Edit and Delete existing media items
sub_choice = sub_menu()
if sub_choice == "1":
# edit selected item
display_searched_book.media_title = edit_check(
'Title', display_searched_book.media_title)
display_searched_book.media_type = edit_check(
'Media Type', display_searched_book.media_type)
display_searched_book.artist = edit_check(
'Artist', display_searched_book.artist)
display_searched_book.genre = edit_check(
'Genre', display_searched_book.genre)
display_searched_book.published_date = edit_check(
'Date', display_searched_book.published_date)
display_searched_book.price = edit_check(
'Price', display_searched_book.price)
session.commit()
print("\nBook Details Updated!")
time.sleep(1.5)
elif sub_choice == "2":
# delete
session.delete(display_searched_book)
session.commit()
print('\nBook Deleted!')
time.sleep(1.5)
time.sleep(1.5)
# end of option 3
elif choice == '4':
# analyse - media item details
# Data points
oldest_media = session.query(Media).order_by(
Media.published_date).first()
newest_media = session.query(Media).order_by(
Media.published_date.desc()).first()
# Get a total count of all the books
total_media = session.query(Media).count()
# Search records with specified text and return number
search_media_count = session.query(Media).filter(
Media.media_title.like('%Media%')).count()
# records after 2015
# after_2015 = session.query(Media).filter(Media.published_date >= datetime.date("2015 01 01"))
# print - formatting analyses for command line
print('\n*****Analyse Media on DB*****')
print(f'''
\rOldest Media: { oldest_media }
\rNewest Media: { newest_media }
\r\nTotal Records in the Database: { total_media }
\r\nSearch "%Media%" Count: { search_media_count }
''')
input('\n Press Enter to return to the main menu.')
else:
# default option to exit the application
print('\n\nGOODBYE')
app_running = False
def show():
form_pass = ChangePassWord()
user = User.query.filter_by(username=current_user.username).first()
if form_pass.validate_on_submit():
if not user.is_correct_password(form_pass.lastpass.data):
flash('初始密码错误')
return redirect('/accounts/settings')
else:
if form_pass.confirpass.data != form_pass.newpass.data:
flash('两次密码不一致')
return redirect('/accounts/settings')
else:
user.password = form_pass.newpass.data
db.session.commit()
flash('修改成功')
return redirect('/accounts/settings')
username = current_user.username
user_content = Content.query.filter_by(user_name=username).order_by(
Content.pub_date.desc()).first()
form = ContentForm()
if form.validate_on_submit():
if user_content == None:
new_content = Content(body=form.contentbox.data, user=current_user)
db.session.add(new_content)
user.nickname = form.nickname.data
db.session.commit()
return redirect('accounts/settings')
else:
user.nickname = form.nickname.data
db.session.commit()
user_content.body = form.contentbox.data
db.session.commit()
return redirect('/accounts/settings')
form_media = MediaForm()
user_media = Media.query.filter_by(user_name=username).first()
if form_media.validate_on_submit():
if user_media == None:
media_setting = Media(
user=current_user,
weibo=form_media.weibo.data,
weixin=form_media.weixin.data,
douban=form_media.douban.data,
twitter=form_media.twitter.data,
github=form_media.github.data,
zhihu=form_media.zhihu.data,
)
db.session.add(media_setting)
db.session.commit()
if form_media.weibo.data != '' and user_media != None:
user_media.weibo = form_media.weibo.data
db.session.commit()
if form_media.weixin.data != '' and user_media != None:
user_media.weixin = form_media.weixin.data
db.session.commit()
if form_media.douban.data != '' and user_media != None:
user_media.douban = form_media.douban.data
db.session.commit()
if form_media.twitter.data != '' and user_media != None:
user_media.twitter = form_media.twitter.data
db.session.commit()
if form_media.github.data != '' and user_media != None:
user_media.github = form_media.github.data
db.session.commit()
if form_media.zhihu.data != '' and user_media != None:
user_media.zhihu = form_media.zhihu.data
db.session.commit()
return redirect('/accounts/settings')
useravatar = User.query.filter_by(username=username).first()
if request.method == 'POST':
global file
file = request.files['file']
useravatar.avatar = secure_filename(file.filename)
db.session.commit()
if file and allowed_file(file.filename):
global filename
filename = secure_filename(file.filename)
file.save(os.path.join(UPLOAD_FOLDER, filename))
avatar_url = url_for('uploaded_file', filename=filename)
return redirect('accounts/settings')
return render_template('/accounts/settings.html',
form=form,
user_content=user_content,
form_media=form_media,
user_media=user_media,
file=file,
useravatar=useravatar,
form_pass=form_pass,
user=user)
