def pick_thumb_nail(video_id, account, thumbnail_id=1):
session = account.http_settings.session
proxy = account.http_settings.proxy
if not account.is_logined():
raise NotLogined('YouPorn account is not logined')
url = 'http://www.youporn.com/change/video-thumbnail/' \
'{videoId}/{thumbnailId}/'.format(videoId=video_id, thumbnailId=thumbnail_id)
post = {'video_id': video_id, 'selectedThumbnail': thumbnail_id}
update_thumbnail = session.post(url, data=post, proxies=proxy)
response = json.loads(update_thumbnail.content)
if 'status' in response:
if response['status'] == 'error':
raise FailedChangingThumbnailId(
'Failed Changing thumbnail_'
'id:{t} on video_id:{v} message:'
'{msg}'.format(t=thumbnail_id,
v=video_id,
msg=response['message']))
else:
raise FailedChangingThumbnailId('Failed Changing thumbnail_'
'id:{t} on video_id:{v}'.format(
t=thumbnail_id, v=video_id))
return True
def change_video_pin_settings(video_id, settings, account):
session = account.http_settings.session
proxy = account.http_settings.proxy
if not account.is_logined():
raise NotLogined('Sex account is not logined')
url = 'http://www.sex.com/pin/edit/{video_id}'.format(
video_id=video_id)
post = {
'board_id': settings['board_id'],
'custom_tags': ",".join([t for t in settings['tags']]),
'title': settings['title'],
'submit': 'Save Changes'
}
change_pin = session.post(url, data=post, proxies=proxy)
doc = etree.fromstring(change_pin.content, HTMLParser())
if doc.xpath('//h2'):
if doc.xpath(
'//h2'
)[0].text == "The page you're looking for could not be found.":
raise InvalidVideoUrl(
'Invalid video id, it could not be found on sex.com')
return True
def update_video_settings(settings, video_id, account):
session = account.http_settings.session
proxy = account.http_settings.proxy
session.headers.update({"X-Requested-With": "XMLHttpRequest"})
if not account.is_logined():
raise NotLogined('YouPorn account is not logined')
post = {
"videoedit[title]":
settings['title'],
"videoedit[description]":
settings['description'],
"videoedit[tags]":
settings['tags'],
"videoedit[pornstars]":
settings['porn_stars'],
"videoedit[video_options_private]":
settings['is_private'],
"videoedit[video_options_password]":
settings['password'],
"videoedit[video_options_disable_commenting]":
settings['allow_comments'],
"videoedit[uploader_category_id]":
settings['category_id'],
"videoedit[orientation]":
settings['orientation']
}
url = 'http://www.youporn.com/change/video/{videoId}/'.format(
videoId=video_id)
update_settings = session.post(url, data=post, proxies=proxy)
response = json.loads(update_settings.content)
del session.headers['X-Requested-With']
if 'success' in response:
if not response['success']:
errors = []
for key in response['errors']:
errors.append("{k} = {v}".format(
k=key, v=response['errors'][key]))
raise FailedUpdatingVideoSettings(
'Failed updating video settings errors:{e}'.format(
",".join(errors)))
else:
return True
else:
raise FailedUpdatingVideoSettings(
'Unknown status:{s}'.format(s=update_settings.content))
def start(self):
try:
if not isinstance(self.video_upload_request,
RedTubeVideoUploadRequest):
raise InvalidVideoUploadRequest(
'Invalid video_upload_request, '
'it needs to be a RedTubeVideoUploadRequest instance')
if not isinstance(self.account, RedTubeAccount):
raise InvalidAccount(
'Invalid account, it needs to be a RedTubeAccount instance'
)
if not self.account.is_logined():
raise NotLogined('RedTube account is not logined')
session = self.account.http_settings.session
proxy = self.account.http_settings.proxy
session.get('http://www.redtube.com/uploadsplash', proxies=proxy)
self.call_hook('started',
video_upload_request=self.video_upload_request,
account=self.account)
session.post('http://www.redtube.com/upload/islogged',
proxies=proxy)
self._upload()
except Exception as exc:
del session.headers["X-Requested-With"]
self.call_hook('failed',
video_upload_request=self.video_upload_request,
account=self.account,
traceback=traceback.format_exc(),
exc_info=sys.exc_info())
if self.bubble_up_exception:
raise exc
else:
del session.headers["X-Requested-With"]
self.call_hook('finished',
video_request=self.video_upload_request,
account=self.account,
settings={''})
return {'status': True}
def get_thumb_nails(video_id, account):
session = account.http_settings.session
proxy = account.http_settings.proxy
if not account.is_logined():
raise NotLogined('YouPorn account is not logined')
go_to_thumbnails = session.get(
'http://www.youporn.com/myuploads/edit/thumbnails', proxies=proxy)
xpath = '//div[@class="pickThumbnails content-box grid_15"]//div[@class="videoRow"]'
doc = etree.fromstring(go_to_thumbnails.content, HTMLParser())
get_videos = doc.xpath(xpath)
found_video = False
for div in get_videos:
current_video_id = div.attrib['id'].replace('videoRow_', '')
if str(current_video_id) == str(video_id):
vid_doc = etree.fromstring(tostring(div), HTMLParser())
xpath = '//div[@class="rightContainer"]//div[@class="thumbnailGrid/div[@class="selectThumbnail"]'
get_thumbnails = vid_doc.xpath(xpath)
thumbnails = []
for thumbnail in get_thumbnails:
current_thumbnail_id = thumbnail.attrib['data-thumbnail']
thumb_doc = etree.fromstring(tostring(thumbnail),
HTMLParser())
img_src = thumb_doc.xpath('//img[@src]')[0]
thumbnails.append(
(current_thumbnail_id, img_src.attrib['src']))
break
if not found_video:
raise VideoNotReadyForThumbnail(
'Video not ready for thumbnail change')
else:
return thumbnails
def create(cls,name,description,account):
session = account.http_settings.session
proxy = account.http_settings.proxy
if type(account) != SexAccount:
raise InvalidAccount('Invalid account, '\
'it needs to be a SexAccount instance')
if not account.is_logined():
raise NotLogined('Sex account is not logined')
create_board_form = session.get('http://www.sex.com/board/edit',proxies=proxy)
post = {'name':name,'description':description,'submit':'Create Board'}
create_new_board = session.post('http://www.sex.com/board/edit',data=post,proxies=proxy)
doc = etree.fromstring(create_new_board.content,HTMLParser())
find_errors = doc.xpath('//div[@class="error"]/text()')
if find_errors:
if find_errors[0] == 'Already Taken':
raise BoardAlreadyTaken('Board: "{b}" already taken'.format(b=name))
else:
raise BoardProblem('Error while creating a new Board:"{b}" Error Message:{e}'.format(b=name,e=find_errors[0]))
boards = doc.xpath('//div[@class="masonry_box small_board_box"]')
for board in boards:
board_doc = etree.fromstring(tostring(board),HTMLParser())
get_title = board_doc.xpath('//div[@class="title"]//strong')
if not get_title:
raise BoardProblem('Cannot find new board name that was created')
if get_title[0].text == name:
get_board_id = board_doc.xpath('//a[@class="btn btn-block"]/@href')
if not get_board_id:
raise BoardProblem('Cannot find new board id that was created')
board_id = get_board_id[0].replace('/board/edit/','')
return cls(name=name,board_id=board_id,description=description)
raise BoardProblem('Could not find board name inside dashboard')
def _prepare_upload(self):
session = self.account.http_settings.session
proxy = self.account.http_settings.proxy
if not self.account.is_logined():
raise NotLogined('YouPorn account is not logined')
upload_page = session.get('http://www.youporn.com/upload',
proxies=proxy)
doc = etree.fromstring(upload_page.content, HTMLParser())
callback_url = doc.xpath('//input[@name="callbackUrl"]/@value')[0]
session.headers.update({
"X-Requested-With":
"XMLHttpRequest",
"Content-Type":
"application/x-www-form-urlencoded; charset=UTF-8"
})
video_size = os.path.getsize(self.video_upload_request.video_file)
video = path.Path(self.video_upload_request.video_file)
post = {'file': video.name, 'size': video_size}
create_upload_request = session.post(
'http://www.youporn.com/upload/create-videos/',
data=post,
proxies=proxy)
response = json.loads(create_upload_request.content)
if 'success' in response:
if not response['success']:
raise FailedUpload(
'Failed to upload video reason:{reason}'.format(
reason=response['reason']))
del session.headers['X-Requested-With']
response['callback_url'] = callback_url
return response
def _update_temporary_video_pin(self, tmp_video):
if not self.account.is_logined():
raise NotLogined('Sex account is not logined')
session = self.account.http_settings.session
proxy = self.account.http_settings.proxy
url = 'http://upload.sex.com/pin/create?video=1&tmpFile={tmp}&from=upload'.format(
tmp=tmp_video)
session.get(url, proxies=proxy)
url = 'http://www.sex.com/pin/create?video=1&tmpFile={tmp}&from=upload'.format(
tmp=tmp_video)
post = {
"custom_tags":
",".join(
[t.name.lower() for t in self.video_upload_request.sex_tags]),
"tags[]":
self.video_upload_request.sex_tags[0].name.lower(),
"board":
self.video_upload_request.board.board_id,
"board_name":
self.video_upload_request.board.name,
"title":
str(self.video_upload_request.title),
"submit":
"Pin It"
}
set_settings = session.post(url, data=post, proxies=proxy)
if 'Congratulations! Your pin has been added.' in set_settings.content:
doc = etree.fromstring(set_settings.content, HTMLParser())
get_video_id = doc.xpath(
'//a[@target="_blank"]')[0].attrib['href'].replace(
'http://www.sex.com/pin/', '').replace('/', '')
return int(get_video_id)
else:
raise FailedUpload('Unknown problem, failed pinning video')
def start(self, **kwargs):
try:
if not isinstance(self.video_upload_request,
TnaflixVideoUploadRequest):
raise InvalidVideoUploadRequest('Invalid video_upload_request, ' \
'it needs to be a TnaflixVideoUploadRequest instance')
if not isinstance(self.account, TnaflixAccount):
raise InvalidAccount(
'Invalid account, it needs to be a TnaflixAccount instance'
)
if not self.account.is_logined():
raise NotLogined('Tnaflix account is not logined')
session = self.account.http_settings.session
proxy = self.account.http_settings.proxy
session.get('https://www.tnaflix.com/upload.php', proxies=proxy)
self.call_hook('started',
video_upload_request=self.video_upload_request,
account=self.account)
if isinstance(self.video_upload_request.category, (list, tuple)):
channel_ids = [
t.category_id for t in self.video_upload_request.category
]
else:
channel_ids = [self.video_upload_request.category.category_id]
fields = []
ready_tag_ids = [('chlist[]', str(c)) for c in channel_ids]
fields.append(
('field_myvideo_title', self.video_upload_request.title.name))
fields.append(('field_myvideo_descr',
self.video_upload_request.description.name))
fields.append(
('field_myvideo_keywords',
" ".join([t.name for t in self.video_upload_request.tags])))
fields.append(('declared', 'on'))
fields.append(('action_upload', str(1)))
fields.append(('code', ''))
fields.append(('uuid', ''))
fields.extend(ready_tag_ids)
encoder = type(self).create_multipart_encoder(fields=fields)
self.upload_monitor = type(self).create_multipart_monitor(encoder)
session.post(
'http://tna.flixupload.com/uploads.php',
data=self.upload_monitor,
headers={'Content-Type': self.upload_monitor.content_type},
proxies=proxy)
self.upload_monitor = type(self).create_multipart_monitor(
encoder=encoder, callback=self._hooks['uploading'])
self.call_hook('uploading',
video_upload_request=self.video_upload_request,
account=self.account)
tags = tuple([t.name for t in self.video_upload_request.tags])
description = self.video_upload_request.description.name
title = self.video_upload_request.title.name
tag_ids = channel_ids
video_file = self.video_upload_request.video_file
uploader = UbrUploader(domain='http://tna.flixupload.com',
path_to_ubr='/',
http_settings=self.account.http_settings,
callback=self._hooks['uploading'])
upload_id = uploader.upload(video_file, title, tags, description,
tag_ids)
url = 'http://tna.flixupload.com/uploads.php?upload_id={id}'.format(
id=upload_id)
session.get(url, proxies=proxy)
except Exception as exc:
self.call_hook('failed',
video_upload_request=self.video_upload_request,
account=self.account,
traceback=traceback.format_exc(),
exc_info=sys.exc_info())
if self.bubble_up_exception:
raise exc
else:
self.call_hook('finished',
video_request=self.video_upload_request,
account=self.account,
settings={'video_id': upload_id})
return {'status': True, 'video_id': upload_id}
def start(self):
try:
if not isinstance(self.video_upload_request,
HardSexTubeVideoUploadRequest):
raise InvalidVideoUploadRequest(
'Invalid video_upload_request, '
'it needs to be a HardSexTubeVideoUploadRequest instance')
if not isinstance(self.account, HardSexTubeAccount):
raise InvalidAccount(
'Invalid account, it needs to be a HardSexTubeAccount instance'
)
if not self.account.is_logined():
raise NotLogined('HardSexTube account is not logined')
session = self.account.http_settings.session
proxy = self.account.http_settings.proxy
video_file = self.video_upload_request.video_file
tags = self.video_upload_request.tags
title = self.video_upload_request.title
description = self.video_upload_request.description
tags = self.video_upload_request.tags
porn_star = self.video_upload_request.porn_star
thumbnail_id = self.video_upload_request.thumbnail_id
category = self.video_upload_request.category
if isinstance(category, HardSexTubeCategoryStraight):
orientation = 'straight'
elif isinstance(category, HardSexTubeCategoryGay):
orientation = 'gay'
elif isinstance(category, HardSexTubeCategoryTranssexual):
orientation = 'tranny'
else:
raise InvalidCategory('Hardsextube category needs to be straight' \
' gay or transsexual')
self.call_hook('started',
video_upload_request=self.video_upload_request,
account=self.account)
go_to_upload_center = session.get(
'http://uploadcenter.hardsextube.com/', proxies=proxy)
doc = etree.fromstring(go_to_upload_center.content, HTMLParser())
found_upload_id = doc.xpath('//input[@name="upload_id"]/@value')
if not found_upload_id:
raise CannotFindVar(
'Unable to find upload_id for hardsextube upload')
upload_id = found_upload_id[0]
thumbnail_ids = self._upload(video_file, upload_id)
if int(thumbnail_id) > len(thumbnail_ids):
raise InvalidThumbnailId(
'Invalid thumbnail_id:{i} for HardSexTube video'.format(
i=thumbnail_id))
self._log_start(upload_id)
self._log_client(upload_id)
self._submit_upload('form_validation', upload_id, title,
description, orientation, category, tags,
porn_star, thumbnail_id)
self._submit_upload('store', upload_id, title, description,
orientation, category, tags, porn_star,
thumbnail_id)
except Exception as exc:
self.call_hook('failed',
video_upload_request=self.video_upload_request,
account=self.account,
traceback=traceback.format_exc(),
exc_info=sys.exc_info())
if self.bubble_up_exception:
raise exc
else:
self.call_hook('finished',
video_request=self.video_upload_request,
account=self.account,
settings={''})
return {'status': True}
def start(self):
try:
if not isinstance(self.video_upload_request,
FuxVideoUploadRequest):
raise InvalidVideoUploadRequest('Invalid video_upload_request, ' \
'it needs to be a FuxVideoUploadRequest instance')
if not isinstance(self.account, FuxAccount):
raise InvalidAccount(
'Invalid account, it needs to be a FuxAccount instance')
if not self.account.is_logined():
raise NotLogined('F*x account is not logined')
self.call_hook('started',
video_upload_request=self.video_upload_request,
account=self.account)
domain = "http://f*x.com"
website = "f*x"
username = self.account.username
http_settings = self.account.http_settings
drop_incorrect_tags = self.video_upload_request.drop_incorrect_tags
add_all_autocorrect_tags = self.video_upload_request.add_all_autocorrect_tags
autocorrect_tags = self.video_upload_request.autocorrect_tags
uploader = KummUploader(
domain,
website,
username,
http_settings=http_settings,
drop_incorrect_tags=drop_incorrect_tags,
add_all_autocorrect_tags=add_all_autocorrect_tags,
autocorrect_tags=autocorrect_tags)
video_file = self.video_upload_request.video_file
title = self.video_upload_request.title
porn_stars = self.video_upload_request.porn_stars
tags = [t.name for t in self.video_upload_request.tags]
orientation = self.video_upload_request.category.category_id
uploader.upload(video_file, title, porn_stars, tags, orientation)
except Exception as exc:
self.call_hook('failed',
video_upload_request=self.video_upload_request,
account=self.account,
traceback=traceback.format_exc(),
exc_info=sys.exc_info())
if self.bubble_up_exception:
raise exc
else:
self.call_hook('finished',
video_request=self.video_upload_request,
account=self.account,
settings={''})
return {'status': True}
def start(self):
try:
if not isinstance(self.video_upload_request,
YouPornVideoUploadRequest):
raise InvalidVideoUploadRequest(
'Invalid video_upload_request, '
'it needs to be a YouPornVideoUploadRequest instance')
if not isinstance(self.account, YouPornAccount):
raise InvalidAccount(
'Invalid account, it needs to be a YouPornAccount instance'
)
if not self.account.is_logined():
raise NotLogined('YouPorn account is not logined')
upload_requested = self._prepare_upload()
self.call_hook('started',
video_upload_request=self.video_upload_request,
account=self.account)
user_uploader_id = upload_requested['user_uploader_id']
video_id = upload_requested['video_id']
callback_url = upload_requested['callback_url']
session = self.account.http_settings.session
proxy = self.account.http_settings.proxy
session.headers.update({"X-Requested-With": "XMLHttpRequest"})
video_file = self.video_upload_request.video_file
encoder = type(self).create_multipart_encoder(
fields={
'userId': str(user_uploader_id),
'videoId': str(video_id),
'callbackUrl': str(callback_url),
'files': (path.Path(video_file).name,
open(video_file, 'rb'))
})
self.upload_monitor = type(self).create_multipart_monitor(
encoder=encoder, callback=self._hooks['uploading'])
self.call_hook('uploading',
video_upload_request=self.video_upload_request,
account=self.account)
session.post(
'http://www.youporn.com/videouploading',
data=self.upload_monitor,
proxies=proxy,
headers={'Content-Type': self.upload_monitor.content_type})
del session.headers['X-Requested-With']
settings = self.video_upload_request.create_video_settings()
session.get(callback_url, proxies=proxy)
type(self).update_video_settings(settings, video_id, self.account)
except Exception as exc:
self.call_hook('failed',
video_upload_request=self.video_upload_request,
account=self.account,
traceback=traceback.format_exc(),
exc_info=sys.exc_info())
if self.bubble_up_exception:
raise exc
else:
self.call_hook('finished',
video_request=self.video_upload_request,
account=self.account,
settings={'video_id': upload_requested['video_id']})
return {'status': True, 'video_id': upload_requested['video_id']}
def start(self):
try:
if not isinstance(self.video_upload_request,
PornhubVideoUploadRequest):
raise InvalidVideoUploadRequest(
'Invalid video_upload_request, '
'it needs to be a PornhubVideoUploadRequest instance')
if not isinstance(self.account, PornhubAccount):
raise InvalidAccount(
'Invalid account, it needs to be a PornhubAccount instance'
)
if not self.account.is_logined():
raise NotLogined('Pornhub account is not logined')
self.call_hook('started',
video_upload_request=self.video_upload_request,
account=self.account)
session = self.account.http_settings.session
proxy = self.account.http_settings.proxy
go_to_upload = session.get('http://www.pornhub.com/upload/video',
proxies=proxy)
session.headers.update({"X-Requested-With": "XMLHttpRequest"})
container = go_to_upload.content.\
split('<div class="saveBlockContent">')[1].\
split('</div><!-- /.saveBlockContent -->')[0]
container = "".join(
['<div class="saveBlockContent">', container, '</div>'])
doc = etree.fromstring(container, HTMLParser())
get_cookie = doc.xpath('//input[@name="cookie[]"]/@value')
get_platform_id = doc.xpath('//input[@name="platformId[]"]/@value')
get_source = doc.xpath('//input[@name="source[]"]/@value')
if len(get_cookie) == 0:
raise CannotFindVar(
'Cannot find input field with name:cookies[]')
if len(get_platform_id) == 0:
raise CannotFindVar(
'Cannot find input field with name:platformId[]')
if len(get_source) == 0:
raise CannotFindVar(
'Cannot find input field with name:source[]')
video_file = self.video_upload_request.video_file
title = self.video_upload_request.title.name
tags = self.video_upload_request.tags
category = self.video_upload_request.category
is_private = self.video_upload_request.is_private
is_homemade = self.video_upload_request.is_homemade
porn_stars = self.video_upload_request.porn_stars
if not isinstance(category, (tuple, list)):
categories = '["{cat}"]'.format(cat=str(category.category_id))
else:
categories = [
'"{c}"'.format(c=str(cat.category_id)) for cat in category
]
categories = '[{cats}]'.format(cats=','.join(categories))
if isinstance(tags, (tuple, list)):
tags = " ".join([t.name for t in tags])
privacy = "private" if is_private else "community"
production = "homemade" if is_homemade else "professional"
fields = []
fields.append(('title', title))
fields.append(('callbackUrl', ''))
fields.append(('platformId', str(get_platform_id[0])))
fields.append(('categories', categories))
fields.append(('tags', tags))
fields.append(('privacy', privacy))
fields.append(('source', str(get_source[0])))
fields.append(('pornstars', porn_stars))
fields.append(('cookie', get_cookie[0]))
fields.append(('production', production))
fields.append(('timestamp', str(generate_timestamp())))
fields.append(('isPremiumVideo', "0"))
fields.append(('Filedata', (path.Path(video_file).name,
open(video_file, 'rb'))))
encoder = type(self).create_multipart_encoder(fields)
self.upload_monitor = type(self).create_multipart_monitor(
encoder=encoder, callback=self._hooks['uploading'])
self.call_hook('uploading',
video_upload_request=self.video_upload_request,
account=self.account)
get_upload_url = re.search(r"var\s+url\s+=\s+'(.*?)',",
go_to_upload.content)
if not get_upload_url:
raise CannotFindVar(
'Cannot find uploading url for pornhub.com')
url = get_upload_url.group(1)
upload_video = session.post(
url,
data=self.upload_monitor,
proxies=proxy,
headers={'Content-Type': self.upload_monitor.content_type})
find_str = '{"@type":["GorillaHub\\\SDKs\\\SDKBundle\\\V0001\\\Domain\\\Responses\\\FileUploadedResponse",[]]'
if find_str not in upload_video.content:
raise FailedUpload(
'Upload possibly failed, did not find success string:{string}'
.format(string=find_str))
except Exception as exc:
del session.headers["X-Requested-With"]
self.call_hook('failed',
video_upload_request=self.video_upload_request,
account=self.account,
traceback=traceback.format_exc(),
exc_info=sys.exc_info())
print traceback.format_exc()
if self.bubble_up_exception:
raise exc
else:
del session.headers["X-Requested-With"]
self.call_hook('finished',
video_request=self.video_upload_request,
account=self.account,
settings={''})
return {'status': True}
def start(self):
try:
if not isinstance(self.video_upload_request,
DrTuberVideoUploadRequest):
raise InvalidVideoUploadRequest('Invalid video_upload_request, ' \
'it needs to be a DrTuberVideoUploadRequest instance')
if not isinstance(self.account, DrTuberAccount):
raise InvalidAccount(
'Invalid account, it needs to be a DrTuberAccount instance'
)
if not self.account.is_logined():
raise NotLogined('DrTuber account is not logined')
session = self.account.http_settings.session
proxy = self.account.http_settings.proxy
go_to_upload = session.get('http://www.drtuber.com/upload/video',
proxies=proxy)
self.call_hook('started',
video_upload_request=self.video_upload_request,
account=self.account)
session.headers.update({
'X-Requested-With':
'XMLHttpRequest',
'Origin':
'http://www.drtuber.com',
'Referer':
'http://www.drtuber.com/upload/video'
})
sid = self._get_avs_value(html=go_to_upload.content)
tmp_filename = self._upload_video(
video_file=self.video_upload_request.video_file, sid=sid)
title = self.video_upload_request.title
categories = self.video_upload_request.category
site_link = self.video_upload_request.site_link
site_name = self.video_upload_request.site_name
is_private = self.video_upload_request.is_private
filename = path.Path(self.video_upload_request.video_file).name
response = self._check_video_commit(commit=tmp_filename)
self._check_title(title=self.video_upload_request.title)
self._submit_upload(title=title,
site_link=site_link,
site_name=site_name,
is_private=is_private,
categories=categories,
tmp_filename=tmp_filename,
filename=filename)
response = self._check_video_commit(commit=tmp_filename)
found_thumbnails = False
thumbnail_id = self.video_upload_request.thumbnail_id
total_loops = 10
current_loop = 0
while not found_thumbnails:
status = response["status"]
if status == "6":
if "thumbs" in response:
if len(response["thumbs"]) + 1 > int(thumbnail_id):
raise InvalidThumbnailId(
'Invalid thumbnail_id is not in the thumbnail range'
)
self._set_video_thumbnail(
filename=filename,
thumbnail_id=int(int(thumbnail_id) - 1))
found_thumbnails = True
else:
current_loop += 1
if current_loop == total_loops:
raise FailedUpload(
'{loops} loops went by and no status 6 was found'.
format(loops=total_loops))
if not found_thumbnails:
time.sleep(5)
except Exception as exc:
del session.headers['X-Requested-With']
del session.headers['Origin']
del session.headers['Referer']
self.call_hook('failed',
video_upload_request=self.video_upload_request,
account=self.account,
traceback=traceback.format_exc(),
exc_info=sys.exc_info())
if self.bubble_up_exception:
raise exc
else:
del session.headers['X-Requested-With']
del session.headers['Origin']
del session.headers['Referer']
self.call_hook('finished',
video_request=self.video_upload_request,
account=self.account,
settings={'tmp_filename': tmp_filename})
return {'status': True, 'tmp_filename': tmp_filename}
def start(self, **kwargs):
try:
if type(self.video_upload_request) != SexVideoPinRequest:
raise InvalidVideoUploadRequest('Invalid pin_video_request, '\
'it needs to be a SexVideoPinRequest instance')
if type(self.account) != SexAccount:
raise InvalidVideoUploadRequest('Invalid account, '\
'it needs to be a SexAccount instance')
if not self.account.is_logined():
raise NotLogined('Sex account is not logined')
session = self.account.http_settings.session
proxy = self.account.http_settings.proxy
self.call_hook('started',
video_upload_request=self.video_upload_request,
account=self.account)
video_upload = session.get('http://upload.sex.com/video/add',
proxies=proxy)
find_sess_sex = re.findall(r"{'sess_sex' : '(.*?)'",
video_upload.content, re.I | re.M)
if not find_sess_sex:
raise FailedUpload(
'Could not find sess_sex, its needed to upload')
sess_sex = find_sess_sex[0]
video_file = self.video_upload_request.video_file
video_data = type(self).create_multipart_encoder(
fields={
'Filename':
path.Path(video_file).name,
'sess_sex':
sess_sex,
'Upload':
'Submit Query',
'Filedata': (path.Path(video_file).name,
open(video_file, 'rb'))
})
self.upload_monitor = type(self).create_multipart_monitor(
encoder=video_data, callback=self._hooks['uploading'])
attempt_upload = session.post('http://upload.sex.com/video/upload',
data=self.upload_monitor,
proxies=proxy,
headers={
'Content-Type':
self.upload_monitor.content_type,
"Connection": "Keep-Alive"
})
if attempt_upload.content == 'Error: You cannot upload more than 5 videos per hour':
raise FailedUpload('Reach uploading limit')
video_id = self._update_temporary_video_pin(
tmp_video=attempt_upload.content)
except Exception as exc:
self.call_hook('failed',
video_upload_request=self.video_upload_request,
account=self.account,
traceback=traceback.format_exc(),
exc_info=sys.exc_info())
if self.bubble_up_exception:
raise exc
else:
self.call_hook('finished',
video_request=self.video_upload_request,
account=self.account,
settings={'video_id': video_id})
if video_id:
return {'status': True, 'video_id': video_id}