Python models.Video类代码示例

    def forwards(self, orm):
        try:
            from videos.models import Video
        except ImportError:
            return        
        
        try:
            from statistic import video_view_counter, sub_fetch_total_counter, \
                widget_views_total_counter
        except ImportError:
            if settings.DEBUG:
                return
            raise Exception('Some redis utilits is unavailable, maybe this migration was not updated after refactoring. You can ignore this migration with: python manage.py migrate statistic 0074 --fake, but all statistic data will be lost.')

        try:
            video_view_counter.r.ping()
        except ConnectionError:
            if settings.DEBUG:
                return
            raise Exception('Redis server is unavailable. You can ignore this migration with: python manage.py migrate statistic 00074 --fake, but all statistic data will be lost.')
        
        video_view_counter.delete()
        sub_fetch_total_counter.delete()
        widget_views_total_counter.delete()
        for obj in orm.Video.objects.all():
            video_counter = Video.view_counter(obj.video_id)
            video_counter.delete()
            video_counter.set(obj.view_count)
            video_view_counter.incr(obj.view_count)
            sub_fetch_total_counter.incr(obj.subtitles_fetched_count)
            widget_views_total_counter.incr(Video.widget_views_counter(obj.video_id).get())

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 _create_video(self, video_url):
     video, created = Video.get_or_create_for_url(video_url, self.user)
     self.failUnless(video)
     self.failUnless(created)
     more_video, created = Video.get_or_create_for_url(video_url, self.user)
     self.failIf(created)
     self.failUnlessEqual(video, more_video)        

def main():
    parsed = feedparser.parse(file("mostravideolivre.atom").read())
    for i in parsed.entries:
        mp4_url = i.content[0].src
        ogg_url = mp4_url.replace(".mp4", ".ogg")
        ogg_url = ogg_url.replace(".MP4", ".ogg")
        thumb = ogg_url + ".png"

        video = Video()
        video.title = i.title
        video.creation_date = datetime.now()
        video.summary = i.get("summary", "")
        video.author = i.author
        video.license_name = "Creative Commons - Atribuição - Partilha nos Mesmos " + "Termos 3.0 Não Adaptada"
        video.license_link = "http://creativecommons.org/licenses/by-sa/3.0/"
        video.thumb_url = thumb
        video.save()

        tag = Tag.objects.get_or_create(name="mvl2010")[0]
        tag.save()
        video.tags.add(tag.id)

        url = Url()
        url.url = mp4_url
        url.content_type = 'video/mp4; codecs="avc1.42E01E, mp4a.40.2"'
        url.video = video
        url.save()

        url = Url()
        url.url = ogg_url
        url.content_type = 'video/ogg; codecs="theora, vorbis"'
        url.video = video
        url.save()

 def test_delete_index(self):
     app_config = apps.get_app_config('videos')
     create_index(app_config, 'Video')
     self.assertTrue(index_exists(Video.get_index_name()))
     delete_index(Video.get_index_name())
     with self.assertRaises(IndexNotFound):
         get_index(Video.get_index_name())

 def save(self):
     if self.cleaned_data.get('save_feed'):
         for feed_url in self.feed_urls:
             self.save_feed_url(feed_url)
         
     for vt in self.video_types:
         Video.get_or_create_for_url(vt=vt, user=self.user)
     return len(self.video_types)

    def handle(self, *args, **kwargs):
        try:
            sub_fetch_keys_set.r.ping()
        except:
            if settings.DEBUG:
                raise
            self.handle_error('Statistic update error', '', sys.exc_info())     
            return
        
        count = sub_fetch_keys_set.scard()
        
        while count:
            count -= 1
            key = sub_fetch_keys_set.spop()
            
            if not key:
                break
            
            print 'Handle key: %s' % key
            
            parts = key.split(':')
            d = date(int(parts[-1]), int(parts[-2]), int(parts[-3]))
            
            if len(parts) == 6:
                lang = parts[2]
            else:
                lang = ''
            
            try:
                video = Video.objects.get(video_id=parts[1])
            except Video.DoesNotExist:
                print 'Video does not exist'
                default_connection.delete(key)
                continue
            
            counter_obj, created = SubtitleFetchCounters.objects.get_or_create(date=d, video=video, language=lang)
            counter_obj.count += int(default_connection.getset(key, 0))
            counter_obj.save()
            
        count = changed_video_set.scard()
        
        while count:
            count -= 1

            video_id = changed_video_set.spop()

            if not video_id:
                break
            
            print 'Update statistic for video: %s' % video_id
            
            subtitles_fetched_counter = Video.subtitles_fetched_counter(video_id, True)
            widget_views_counter = Video.widget_views_counter(video_id, True)
            view_counter = Video.view_counter(video_id, True)
            
            Video.objects.filter(video_id=video_id).update(view_count=F('view_count')+view_counter.getset(0))
            Video.objects.update(widget_views_count=F('widget_views_count')+widget_views_counter.getset(0))
            Video.objects.update(subtitles_fetched_count=F('subtitles_fetched_count')+subtitles_fetched_counter.getset(0))

 def test_bliptv_twice(self):
     VIDEO_FILE = 'http://blip.tv/file/get/Kipkay-AirDusterOfficeWeaponry223.m4v'
     from vidscraper.sites import blip
     old_video_file_url = blip.video_file_url
     blip.video_file_url = lambda x: VIDEO_FILE
     Video.get_or_create_for_url('http://blip.tv/file/4395490')
     blip.video_file_url = old_video_file_url
     # this test passes if the following line executes without throwing an error.
     Video.get_or_create_for_url(VIDEO_FILE)

    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 subtitles(request):
    callback = request.GET.get('callback')
    video_url = request.GET.get('video_url')
    language = request.GET.get('language')
    revision = request.GET.get('revision')
    format = request.GET.get('format', 'json')
    
    if video_url is None:
        return {'is_error': True, 'message': 'video_url not specified' }
    
    video, created = Video.get_or_create_for_url(video_url)
    
    if not video:
        return {'is_error': True, 'message': 'unsuported video url' }
    
    if format == 'json':
        output = [s.for_json() for s in video.subtitles(version_no=revision, language_code = language)]

        if callback:
            result = json.dumps(output)
            return HttpResponse('%s(%s);' % (callback, result), 'text/javascript')
        else:
            return output
    else:    
        handler = GenerateSubtitlesHandler.get(format)
        
        if not handler:
            return {'is_error': True, 'message': 'undefined format' }
        
        subtitles = [s.for_generator() for s in video.subtitles(version_no=revision, language_code = language)]

        h = handler(subtitles, video)
        return HttpResponse(unicode(h))

def create(request):
    if request.method == 'POST':
        video_form = VideoForm(request.POST, label_suffix="")
        if video_form.is_valid():
            owner = request.user if request.user.is_authenticated() else None
            video_url = video_form.cleaned_data['video_url']
            try:
                video, created = Video.get_or_create_for_url(video_url, owner)
            except VidscraperError:
                vidscraper_error = True
                return render_to_response('videos/create.html', locals(),
                              context_instance=RequestContext(request))
            messages.info(request, message=u'''Here is the subtitle workspace for your video.  You can
share the video with friends, or get an embed code for your site.  To add or
improve subtitles, click the button below the video''')
            return redirect(video)        
            #if not video.owner or video.owner == request.user or video.allow_community_edits:
            #    return HttpResponseRedirect('{0}?autosub=true'.format(reverse(
            #            'videos:video', kwargs={'video_id':video.video_id})))
            #else:
            #    # TODO: better error page?
            #    return HttpResponse('You are not allowed to add transcriptions to this video.')
    else:
        video_form = VideoForm(label_suffix="")
    return render_to_response('videos/create.html', locals(),
                              context_instance=RequestContext(request))

    def test_youtube_subs_response(self):
        import os
        from videos.types.youtube import YoutubeVideoType
        import urllib
        
        def urlopen_mockup(url, *args, **kwargs):
            path = os.path.join(os.path.dirname(__file__), 'fixtures/youtube_subs_response.json')
            return open(path)
        
        _urlopen = urllib.urlopen
        urllib.urlopen = urlopen_mockup
        
        vt = YoutubeVideoType('http://www.youtube.com/watch?v=GcjgWov7mTM')
        video, create = Video.get_or_create_for_url('http://www.youtube.com/watch?v=GcjgWov7mTM', vt)
        vt._get_subtitles_from_youtube(video)
        video = Video.objects.get(pk=video.pk)
        version = video.version(language_code='en')
        self.assertFalse(version is None)
        self.assertTrue(len(version.subtitles()))
        self.assertEqual(version.subtitles()[0].text, 'I think what is probably the most misunderstood\nconcept in all of science and as we all know')
        subs = version.subtitles()
        subs.sort(key=lambda s: s.start_time)
        for i in range(1, len(subs)):
            self.assertTrue(subs[i].sub_order > subs[i - 1].sub_order)

        urllib.urlopen = _urlopen

 def test_video_cache_busted_on_delete(self):
     start_url = 'http://videos.mozilla.org/firefox/3.5/switch/switch.ogv'
     video, created = Video.get_or_create_for_url(start_url)
     video_url = video.get_video_url()
     video_pk = video.pk
      # 
     cache_id_1 = video_cache.get_video_id(video_url)
     self.assertTrue(cache_id_1)
     video.delete()
     self.assertEqual(Video.objects.filter(pk=video_pk).count() , 0)
     # when cache is not cleared this will return arn 
     cache_id_2 = video_cache.get_video_id(video_url)
     self.assertNotEqual(cache_id_1, cache_id_2)
     # create a new video with the same url, has to have same# key
     video2, created= Video.get_or_create_for_url(start_url)
     video_url = video2.get_video_url()
     cache_id_3 = video_cache.get_video_id(video_url)
     self.assertEqual(cache_id_3, cache_id_2)

def _api_subtitles_json(request):
    video_url = request.GET.get('video_url', None)
    language = request.GET.get('language', None)
    revision = request.GET.get('revision', None)
    if video_url is None:
        return {'is_error': True, 'message': 'video_url not specified' }
    video, created = Video.get_or_create_for_url(video_url)
    return [s.__dict__ for s in video.subtitles(
            version_no=revision, language_code = language)]

 def test_cache_has_right_value(self):
     video_url = VideoUrl.objects.all()[0]
     tv = TeamVideo(video=video_url.video, team=self.team,added_by=self.user)
     tv.save()
     res =  self._get_widget_moderation_status(video_url.url)
     self.assertFalse(res["is_moderated"])
     video, created = Video.get_or_create_for_url(video_url.url)
     add_moderation(video, self.team, self.user)
     res =  self._get_widget_moderation_status(video_url.url)
     self.assertTrue(res["is_moderated"])