def setUp(self): video1 = Video(title='video1') video2 = Video(title='video2') video3 = Video(title='video3') video4 = Video(title='video4') video1.save() video2.save() video3.save() video4.save() category = Category(title='category') category.save() category2 = Category(title='category2') category2.save()
def _execute_crawler(self, term, max_depth, max_breadth): token = os.environ.get('TOKEN_YOUTUBE') crawler = Crawler(site='youtube', site_token=token, max_breadth=max_breadth, max_depth=max_depth) for video in crawler.run(term.split()): if Video.objects.filter(id_source=video.id_source).exists(): continue base_url = 'http://www.youtube.com/watch?v=' db_video = Video(id_source=video.id_source, source='youtube', user=self.get_user(), title=video.title, description=video.description, filename=base_url + video.id_source) db_video.save(force_insert=True) # Could be problematic on sqlite for tag in video.tags: db_video.tags.add(self.get_tag(tag)) # Erase CrawlerBot thread controller self.mutex.acquire() del (self.threads[threading.currentThread().ident]) self.mutex.release()
def create_new_videos(videos_info): videos = [] for video_info in videos_info: video = Video(yt_id=video_info['id'], yt_title=video_info['title'], published_at_yt=video_info['published_at']) video.title = clean_video_title(video_info['title']) video.description = clean_video_description(video_info['description']) video.save() videos.append(video) request = requests.get(video_info['thumbnail_url'], stream=True) if request.status_code == requests.codes.ok: tempimg = tempfile.NamedTemporaryFile() for block in request.iter_content(1024 * 8): if not block: break tempimg.write(block) video.thumbnail = files.File(tempimg) video.save() # make thumbnail be "cut" in the right ratio for the video thumbnails ratio = 275.0 / 154.0 t_width = int( min(video.thumbnail.width, video.thumbnail.height * ratio)) t_height = int( min(video.thumbnail.width / ratio, video.thumbnail.height)) #center the cut y_origin = video.thumbnail.height / 2 - t_height / 2 y_end = y_origin + t_height t_ratio = '0,' + str(y_origin) + str(t_width) + ',' + str(y_end) video.thumbnail_ratio = t_ratio video.save() if 'tags' in video_info: for video_tag in video_info['tags']: tag = Tag.objects.create(video=video, name=video_tag) return videos
def init_cocreate(cocreate, generate_slug): if len(cocreate.videos) <= 0: return if not cocreate.output_video: slug = generate_slug(SLUG_LENGTH) video = Video(title=cocreate.title, slug=slug, description=cocreate.description, uploader=cocreate.owner) video.save() cocreate.output_video = video cocreate.save() else: # reset video status to encoding video_status = cocreate.output_video.get_video_status() video_status.set_to_encoding() #create outline from the sections VideoOutline.objects.filter(video=cocreate.output_video).delete() outline = VideoOutline.objects.create(video=cocreate.output_video) asections = cocreate.available_sections for i in xrange(len(asections)): outline.videooutlinepin_set.create(text=asections[i], current_time=Decimal(str(i))) # enqueue on cocreate task queue enqueue_cocreate(cocreate)
def post(self, request): name = request.data.get("name") reason = request.data.get("reason") src = request.data.get("src") newVid = Video(name=name, reason=reason, src=src) newVid.save() response = Response(status=status.HTTP_200_OK) return response
def save_video(url, languages): client = coreapi.Client() normalized_url = query_string_remove(url) schema = client.get(normalized_url) soup = BeautifulSoup(schema, "html.parser") video_meta_unprocessed = soup.find("div", attrs={ "itemscope": True, "itemtype": "https://schema.org/VideoObject" }) video_meta = BeautifulSoup(str(video_meta_unprocessed), "html.parser") duration = video_meta.find("meta", attrs={"itemprop": "duration"})["content"] license_url = video_meta.find("link", attrs={"itemprop": "license"})["href"] title = video_meta.find("meta", attrs={"itemprop": "name"})["content"] description = video_meta.find("meta", attrs={"itemprop": "description"})["content"] script_unprocessed = str(soup.find("script", attrs={"data-spec": "q"})) openIndex = script_unprocessed.index('{') closeIndex = script_unprocessed.rindex('}') jsonSubstring = script_unprocessed[openIndex:closeIndex + 1] talk_meta = json.loads(jsonSubstring)["__INITIAL_DATA__"] video_id = talk_meta["current_talk"] url = talk_meta["url"] viewed_count = talk_meta["viewed_count"] event = talk_meta["event"] speakers = [] for speaker in talk_meta["speakers"]: name = construct_name(speaker) speakers.append(name) video = Video(video_id=video_id, duration=duration, url=url, license_url=license_url, title=title, description=description, speakers=speakers, event=event, viewed_count=viewed_count) video.save() video_serializer = VideoSerializer(video) django_rq.enqueue(func=save_subtitles, args=[video_id, languages], retry=Retry(max=3, interval=[10, 30, 60])) print(video_serializer.data)
def setUp(self): user = User.objects.create_user(self.fake_username, self.fake_mail, self.fake_pass) self.user = UserProfile(user=user) self.user.save() self.video = Video(title="TITULO", description="DESCRIPCION", author=user) self.video.save() self.chat_room = self.user.chatroom_set.create(video=self.video)
def test_set_values(self): # We should re-empliment this one once we have a way to mock out the # vimeo API. url = u'http://vimeo.com/22070806' vt = VimeoVideoType(url) video = Video() vt.set_values(video) self.assertNotEqual(video.title, '') self.assertNotEqual(video.description, '')
def test_set_values(self, mock_get_video_info): video_info = google.VideoInfo('test-channel-id', 'title', 'description', 100, 'http://example.com/thumb.png') mock_get_video_info.return_value = video_info vt = YoutubeVideoType('http://www.youtube.com/watch?v=_ShmidkrcY0') video = Video() vt.set_values(video) self.assertEqual(video.title, video_info.title) self.assertEqual(video.description, video_info.description) self.assertEqual(video.duration, video_info.duration) self.assertEqual(video.thumbnail, video_info.thumbnail_url)
def test_get_video_info_exception(self, mock_get_video_info): video_info = google.VideoInfo('test-channel-id', 'title', 'description', 100, 'http://example.com/thumb.png') mock_get_video_info.side_effect = google.APIError() vt = YoutubeVideoType('http://www.youtube.com/watch?v=_ShmidkrcY0') video = Video() vt.set_values(video, None, None, None) self.assertEqual(vt.video_id, '_ShmidkrcY0') self.assertEqual(video.description, '') self.assertEqual(video.duration, None) self.assertEqual(video.thumbnail, '')
def test_no_changed_signals_on_initial_created(self): cm1 = test_utils.mock_handler(signals.title_changed) cm2 = test_utils.mock_handler(signals.duration_changed) cm3 = test_utils.mock_handler(signals.language_changed) with cm1 as handler1, cm2 as handler2, cm3 as handler3: video = Video() video.primary_audio_language_code = 'en' video.title = 'foo' video.duration = 123 video.save() assert_equal(handler1.call_count, 0) assert_equal(handler2.call_count, 0) assert_equal(handler3.call_count, 0)
def fetch_and_save(self, after_timestamp): page_token = 'BEGIN' params = { 'part': 'snippet', 'maxResults': 50, 'order': 'date', 'q': settings.QUERY, 'type': 'video', 'pageToken': page_token, 'key': self.current_api_key, 'publishedAfter': after_timestamp.strftime('%Y-%m-%dT%H:%M:%SZ') } videos = [] # get next page if page token available while page_token: if page_token == 'BEGIN': page_token = '' params['pageToken'] = page_token resp = requests.get(url=self.url, params=params, timeout=5) print('Visiting page', resp.status_code) if resp.status_code == status.HTTP_200_OK: items = resp.json()['items'] # check items as page token can be present even if no results after this page if 'nextPageToken' in resp.json() and items: page_token = resp.json()['nextPageToken'] else: page_token = '' for item in items: data = item['snippet'] # response is not correct if time is near to last upload video time # check for incorrect response if after_timestamp.replace(tzinfo=None) >= datetime.strptime(data['publishedAt'], '%Y-%m-%dT%H:%M:%S.%fZ'): page_token = '' break videos.append(Video( title=data['title'], description=data['description'], publish_time=data['publishedAt'], thumbnail=data['thumbnails']['default']['url'], channel_title=data['channelTitle'] )) elif resp.status_code == status.HTTP_403_FORBIDDEN: print('API key quota expired\nUsing new keys...') self.change_api_key() self.fetch_and_save(after_timestamp) else: raise Exception('could not connect to server. please check your API key') Video.objects.bulk_create(videos)
def test_permision_delete_no_loggin(self): useromar = User.objects.create_user(username="******", email="*****@*****.**", password="******") userfer = User.objects.create_user(username="******", email="*****@*****.**", password="******") useromar.save() userfer.save() video = Video(title="omar escabiado", description="omar muy escabiado", author=useromar) video.save() clientomar = Client() response = clientomar.get("/video/"+str(video.id)+"/delete/") self.assertEqual(response.status_code, 302)
def importer(filename, category = "A trier", proj = "A trier 2015"): c = Category.objects.get_or_create(titre=category)[0] p = Proj.objects.get_or_create(titre=proj, category=c, image="http://cdn.wallpapersafari.com/58/12/nyHXSO.jpg")[0] f = open(filename) for x in f.read().splitlines(): false_title = x.split('/')[-1].split('.')[-2].split('_') title = ' '.join(false_title) if len(false_title) > 1: title = ' '.join(false_title[1:]) v = Video(titre=title, url=x) print "Creating {}, {}".format(title, x) v.save() r = Relation_proj(proj=p, video=v) r.save()
def test_permision_delete(self): userpep = User.objects.create_user(username="******", email="*****@*****.**", password="******") userjuan = User.objects.create_user(username="******", email="*****@*****.**", password="******") userpep.save() userjuan.save() video = Video(title="pepito bailando full HD 1 link MEGA", description="Video gracioso de pepito bailando, manito arriba si te gusto", author=userjuan) video.save() clientpepito = Client() clientpepito.login(username=userpep, password="******") response = clientpepito.get("/video/"+str(video.id)+"/delete/") self.assertEqual(response.status_code, 404)
def create(self, validated_data): # logged in required user = ContextUtils(self.context).logged_in_user() # create video video = Video(**validated_data) video.user = user video.save() # add video tags tags = TagBuilder.get_or_create_tags(validated_data['title']) for tag in tags: video.tags.add(tag) return video
def test_get_video_info_exception(self, mock_get_video_info): video_info = google.VideoInfo('test-channel-id', 'title', 'description', 100, 'http://example.com/thumb.png') mock_get_video_info.side_effect = google.APIError() vt = YoutubeVideoType('http://www.youtube.com/watch?v=_ShmidkrcY0') video = Video() vt.set_values(video) self.assertEqual(vt.video_id, '_ShmidkrcY0') self.assertEqual(video.description, '') self.assertEqual(video.duration, None) self.assertEqual(video.thumbnail, '') # since get_video_info failed, we don't know the channel id of our # video URL. We should use a dummy value to make it easier to fix the # issue in the future self.assertEqual(vt.owner_username(), None)
def apiFetch(f_stop): search_url = 'https://www.googleapis.com/youtube/v3/search' video_url = 'https://www.googleapis.com/youtube/v3/videos' search_params = { 'part': 'snippet', 'q': 'nobody', 'key': settings.YOUTUBE_DATA_API_KEY, 'order': 'date', 'type': 'video' } r = requests.get(search_url, params=search_params) results = r.json()['items'] video_ids = [] for result in results: video_ids.append(result['id']['videoId']) query_params = { 'key': settings.YOUTUBE_DATA_API_KEY, 'part': 'snippet,contentDetails', 'id': ','.join(video_ids), 'order': 'date' } r = requests.get(video_url, params=query_params) results = r.json()['items'] videos = [] for result in results: videos.append( Video(title=result['snippet']['title'], video_id=result['id'], url=f'https://www.youtube.com/watch?v={ result["id"] }', duration=timedelta(seconds=parse_duration( result['contentDetails']['duration']).total_seconds()), thumbnail=result['snippet']['thumbnails']['high']['url'])) Video.objects.bulk_create(videos, ignore_conflicts=True) if not f_stop.is_set(): threading.Timer(10, apiFetch, [f_stop]).start()
def incoming_message(request): """ View to receive the webhook request from slack and check for the youtube link. If relevant link is incoming, save the data to DB :param request: :return: Response to slack events API, 200 status and the challenge code from the request in body """ request_body = json.loads(request.body.decode('utf8')) validate_service = SlackService() if validate_service.check_for_message(request_body): message = request_body.get('event').get('message') links = validate_service.retrieve_data(message) relevant_data = validate_service.validate_links(links) relevant_link_objs = [ Video(**link) for link in relevant_data if Video.objects.filter(**link).count() < 1 ] Video.objects.bulk_create(relevant_link_objs) return HttpResponse(status=200, content_type='text/plain')
def save_obj_from_entry(response): """ Takes response object and stores it into db """ v = Video() v.title = response['snippet']['title'] v.ytid = response['id'] unique_slugify(v, v.title) v.published_on = isodate.parse_datetime(response['snippet']['publishedAt']) # get duration of video duration = response["contentDetails"]["duration"] v.duration = int(isodate.parse_duration(duration).total_seconds()) # get description of video try: v.description = response['snippet']['description'] except: pass # get category try: category_response = youtube_api.videoCategories().list( part="snippet", id=response['snippet']['categoryId']).execute() v.category = category_response.get("items", [])[0]['snippet']['title'] except: pass # get thumbnail - "default" try: v.thumbnail = response['snippet']['thumbnails']['default']['url'] except: pass # get view count try: v.views = int(response['statistics']['viewCount']) except: pass v.save() return v
def upload( request ): video = upload_receive( request ) instance = Video( video = video ) instance.save() basename = os.path.basename( instance.video.path ) file_dict = { 'name' : basename, 'size' : video.size, 'url': settings.MEDIA_URL + basename, 'thumbnailUrl': settings.MEDIA_URL + basename, 'deleteUrl': reverse('jfu_delete', kwargs = { 'pk': instance.pk }), 'deleteType': 'POST', } return UploadResponse( request, file_dict )
def create(self, request): data = request.data.get("data") copy_from = request.data.get("copy_from") data.pop("videos", None) data.pop("id", None) album = self.queryset.create(**data, user=request.user) if copy_from: copy_album = self.get_object(copy_from) if copy_album: videos_to_create = [ Video(name=v.name, youtube_id=v.youtube_id, album=album) for v in copy_album.videos.all() ] videos = Video.objects.bulk_create(videos_to_create) serializer = self.serializer_class(album) return JsonResponse(serializer.data)
def _import_video(self, video_url, videoid, title, description, thumbnail, videosrt): videoid_match = VIDEOID_RE.search(videoid) videoid = videoid_match.group(1) video_type = YoutubeVideoType( 'http://www.youtube.com/watch?v={0}'.format(videoid)) try: video_url_obj = VideoUrl.objects.get( url=video_type.convert_to_video_url()) video = video_url_obj.video except ObjectDoesNotExist: video_url_obj = None video = Video() video.youtube_videoid = videoid video.title = title video.description = description if video_type.entry.media.duration: video.duration = int(video_type.entry.media.duration.seconds) video.thumbnail = thumbnail video.save() Action.create_video_handler(video) if videosrt: self._import_srt(video, videosrt) else: SubtitleLanguage(video=video, language='en', is_original=True, is_forked=True).save() if not video_url_obj: video_url_obj = VideoUrl(videoid=videoid, url=video_type.convert_to_video_url(), type=video_type.abbreviation, original=True, primary=True, video=video) video_url_obj.save() self._save_alternate_url(video, video_url)
def video_detail_by_url(request): # POST or update a video for the url defined in the body of the request video_link = JSONParser().parse(request) client = coreapi.Client() normalized_url = query_string_remove(video_link["url"]) schema = client.get(normalized_url) soup = BeautifulSoup(schema, "html.parser") video_meta_unprocessed = soup.find("div", attrs={"itemscope":True, "itemtype":"https://schema.org/VideoObject"}) video_meta = BeautifulSoup(str(video_meta_unprocessed), "html.parser") duration = video_meta.find("meta", attrs={"itemprop":"duration"})["content"] license_url = video_meta.find("link", attrs={"itemprop":"license"})["href"] title = video_meta.find("meta", attrs={"itemprop":"name"})["content"] description = video_meta.find("meta", attrs={"itemprop":"description"})["content"] script_unprocessed = str(soup.find("script", attrs={"data-spec":"q"})) openIndex = script_unprocessed.index('{') closeIndex=script_unprocessed.rindex('}') jsonSubstring = script_unprocessed[openIndex:closeIndex + 1] talk_meta = json.loads(jsonSubstring)["__INITIAL_DATA__"] video_id = talk_meta["current_talk"] url = talk_meta["url"] viewed_count = talk_meta["viewed_count"] event = talk_meta["event"] speakers = [] for speaker in talk_meta["speakers"]: name = construct_name(speaker) speakers.append(name) video = Video(video_id=video_id, duration=duration, url=url, license_url=license_url, title=title, description=description, speakers=speakers, event=event, viewed_count=viewed_count) video.save() video_serializer = VideoSerializer(video) return JsonResponse(video_serializer.data, status=status.HTTP_200_OK)
def post(self, request): data = request.data.get("data") playlist_id = request.data.get("playlist_id") data.pop("videos", None) data.pop("id", None) user_id = request.user.pk video_info = import_videos(playlist_id) album = Album.objects.create(**data, user=request.user) videos = Video.objects.bulk_create( list( map( lambda vinfo: Video( name=vinfo["name"], youtube_id=vinfo["id"], album=album, ), video_info))) serializer = self.serializer_class(album) return JsonResponse(serializer.data, safe=False)
def save_obj_from_entry(entry): """ Takes entry(gdata) object and stores it into db """ v = Video() v.title = entry.media.title.text v.ytid = getid(entry) unique_slugify(v, v.title) v.duration = int(entry.media.duration.seconds) v.description = entry.media.description.text v.published_on = get_date(entry.published.text) v.category = entry.media.category[0].text if entry.rating is not None: v.rating = float(entry.rating.average) if entry.media.thumbnail is not None: v.thumbnail = entry.media.thumbnail[0].url try: v.views = int(entry.statistics.view_count) except: v.views = 0 v.save() return v
def check_get_download_filename(self, title, correct_filename): v = Video() v.title = title self.assertEquals(v.get_download_filename(), correct_filename)
def upload_video(request): if request.method == 'POST' and request.FILES['video_file']: video_file = request.FILES['video_file'] user_id = request.user title = request.POST['title'] desc = request.POST['description'] tags = request.POST['tags'] category = request.POST['category'] cat = VideoCategory.objects.get(id=category) vid = Video(video_id=1, uid=user_id, title=title, description=desc, tags=tags, category=cat, videofile='video_file', thumb='img_output_path') vid.save() video_id = vid.pk vid = Video.objects.get(id=video_id) img_output_path = '%s/thumbnails/%s' % (settings.MEDIA_ROOT, video_id) img_output_path_url = '%sthumbnails/%s' % (settings.MEDIA_URL, video_id) vid.video_id = video_id vid.videofile = video_file vid.save() duration = get_video_length(vid.videofile.path) pertime = duration / 20 ff = FFmpeg(inputs={vid.videofile.path: None}, outputs={ img_output_path + '_%d.jpg': ['-vf', 'fps=1/' + str(pertime), '-vframes', '20'] }) ff.run() vid.thumb = img_output_path + '_1.jpg' vid.thumb_url = img_output_path_url + '_1.jpg' vid.duration = duration vid.save() # Proses Tagging list_tags = tags.split(',') list_tags = [i.strip().lower() for i in list_tags] for tg in list_tags: if VideoTag.objects.filter(tag=tg).exists(): current_tag = VideoTag.objects.filter(tag=tg).first() current_tag.videos.add(vid) else: create_tag = VideoTag(uid=user_id, tag=tg) create_tag.save() create_tag.videos.add(vid) vc_list = VideoCategory.objects.all() context = {'vc_list': vc_list} #return render(request, 'upload-video.html', context) else: vc_list = VideoCategory.objects.all() form = VideoForm() context = {'form': form, 'vc_list': vc_list} #return render(request, 'upload-video.html', context) return render(request, 'upload-video.html', context)
def handle(self, *args, **options): if len(args) > 2: raise CommandError('Too many arguments given. Provide either one or two usernames.') elif len(args) == 2: try: free_user = User(username=args[0], first_name=args[0] + '_free', last_name='User', email='*****@*****.**') paid_user = User(username=args[1], first_name=args[1] + '_paid', last_name='User', email='*****@*****.**') free_user.save() paid_user.save() self.stdout.write('Successfully created fake users using supplied usernames.\n') except: raise CommandError("Could not create users with supplied usernames. Try different usernames.") elif len(args) == 1: try: free_user = User(username=args[0] + '_free', first_name=args[0] + '_free', last_name='User', email='*****@*****.**') paid_user = User(username=args[0] + '_paid', first_name=args[0] + '_paid', last_name='User', email='*****@*****.**') free_user.save() paid_user.save() self.stdout.write('Successfully created fake users using the supplied username + suffixes "_free" and "_paid".\n') except: raise CommandError("Could not create users with supplied username. Try a different username.") elif len(args) == 0: try: free_user = User(username='******', first_name='fakeuser_free', last_name='User', email='*****@*****.**') paid_user = User(username='******', first_name='fakeuser_paid', last_name='User', email='*****@*****.**') free_user.save() paid_user.save() self.stdout.write('Successfully created fake users using default usernames.\n') except: raise CommandError("Fake users already exist. Create differently named users using 'manage.py create_test_accounts <username>'") free_user.set_password('password') paid_user.set_password('password') free_user.save() paid_user.save() # Set paid_user account paid_level = AccountLevel.objects.get(level='Paid') paid_user.userprofile.account_level = paid_level paid_user.userprofile.save() # Create videos for free users for u in (free_user, paid_user): created_videos = () for i in range(10): temp_slug = generate_slug(5) temp_vid = Video(uploader=u, title="Test Fake Uploads Video " + str(i), slug=temp_slug) temp_vid.save() created_videos = created_videos + (temp_vid,) #### Videos #Normal temp_vid = created_videos[0] temp_vid.title = "Normal private video" temp_vid.description = "Normal private video." temp_vid.save() upload_to_s3(temp_vid.slug) ### Expired videos, for free user temp_vid = created_videos[1] if not u == free_user: upload_to_s3(temp_vid.slug) temp_vid = created_videos[2] upload_to_s3(temp_vid.slug) temp_vid = created_videos[3] upload_to_s3(temp_vid.slug) #Expired Yesterday, created 2 days ago temp_vid = created_videos[1] temp_vid.title = "Expired the day previous to creation" temp_vid.description = "Expired the day previous to creation." temp_vid.created = datetime.datetime.now() - datetime.timedelta(days=2) temp_vid.save() if u == free_user: temp_vid.expired = True temp_vid.expiry_date = datetime.datetime.now() - datetime.timedelta(days=1) temp_vid.save() temp_vid.delete() #Expires Today in 4 hours temp_vid = created_videos[2] temp_vid.title = "Expires 4 hours from creation" temp_vid.description = "Expires 4 hours from creation." if u == free_user: temp_vid.expiry_date = datetime.datetime.now() + datetime.timedelta(hours=4) temp_vid.save() #Expires in 3 days temp_vid = created_videos[3] temp_vid.title = "Expires 3 days from creation" temp_vid.description = "Expires 3 days from creation." if u == free_user: temp_vid.expiry_date = datetime.datetime.now() + datetime.timedelta(days=3) temp_vid.save() #Created Yesterday temp_vid = created_videos[4] upload_to_s3(temp_vid.slug) temp_vid.created = datetime.datetime.now() - datetime.timedelta(days=1) temp_vid.title = "Time-stamped as created the day previous to actual creation" temp_vid.description = "Time-stamped as created the day previous to actual creation." temp_vid.save() #Created A Week Previous temp_vid = created_videos[5] upload_to_s3(temp_vid.slug) temp_vid.created = datetime.datetime.now() - datetime.timedelta(days=7) temp_vid.title = "Time-stamped as created a week previous to actual creation" temp_vid.description = "Time-stamped as created a week previous to actual creation." temp_vid.save() #Public temp_vid = created_videos[6] upload_to_s3(temp_vid.slug) temp_vid.is_public = True temp_vid.title = "Public." temp_vid.description = "Public." temp_vid.save() #Public. Expired Yesterday, created 2 days ago temp_vid = created_videos[7] upload_to_s3(temp_vid.slug) temp_vid.title = "Public. Expired the day previous to creation" temp_vid.description = "Public. Expired the day previous to creation." temp_vid.is_public = True temp_vid.created = datetime.datetime.now() - datetime.timedelta(days=2) if u == free_user: temp_vid.expired = True temp_vid.expiry_date = datetime.datetime.now() - datetime.timedelta(days=1) temp_vid.save() #Outlined temp_vid = created_videos[8] upload_to_s3(temp_vid.slug) temp_vid.title = "Outlined" temp_vid.description = "Outlined." temp_vid.save() outline = VideoOutline(video=temp_vid) outline.save() outline_pin = VideoOutlinePin(video_outline=outline, text="Start") outline_pin.save() #Transferred to Youtube, created 2 days ago, deleted from server yesterday temp_vid = created_videos[9] upload_to_s3(temp_vid.slug) temp_vid.youtube_embed_url= "http://www.youtube.com/embed/yc5W-AClSlI" temp_vid.created = datetime.datetime.now() - datetime.timedelta(days=2) temp_vid.youtube_video_expiry_date = datetime.datetime.now() - datetime.timedelta(days=1) temp_vid.title = "YouTube video" temp_vid.description = "YouTube video." temp_vid.save() self.stdout.write('Successfully created videos!\n')
'video_id': item['contentDetails']['videoId'], 'published_at': item['contentDetails']['videoPublishedAt'] }) for video in videos: video['description'] = video['description'].replace('\n', '<br>') print(' # [' + video['title'] + '] ' + video['published_at'] + ' ' + video['video_id'] + ' ' + video['thumbnail_medium']) print(' # TOTAL NUMBER: ' + str(len(videos))) category = Category.objects.get(url=CATEGORY_URL) count = 0 for v in videos: video = Video(category=category, video_id=v['video_id'], title=v['title'], thumbnail_medium=v['thumbnail_medium'], published_at=v['published_at'], description=v['description']) video.save() count += 1 print(' # Video added: (' + str(video.pk) + ') ' + video.title) print(' # FINISHED!') print('Added ' + str(count) + ' videos.')