Access the Video Twilio Domain

        :returns: Video Twilio Domain
        :rtype: twilio.rest.video.Video
550222
def video(self):
        
        if self._video is None:
            from twilio.rest.video import Video
            self._video = Video(self)
        return self._video
1323393
def _get_video(edx_video_id):
    
    try:
        return Video.objects.prefetch_related("encoded_videos", "courses").get(edx_video_id=edx_video_id)
    except Video.DoesNotExist:
        error_message = u"Video not found for edx_video_id: {0}".format(edx_video_id)
        raise ValVideoNotFoundError(error_message)
    except Exception:
        error_message = u"Could not get edx_video_id: {0}".format(edx_video_id)
        logger.exception(error_message)
        raise ValInternalError(error_message)
43993
def get_video_frames(self, path):
        
        videogen = skvideo.io.vreader(path)
        frames = np.array([frame for frame in videogen])
        return frames
663408
def get_video_transcript_url(video_id, language_code):
    
    video_transcript = VideoTranscript.get_or_none(video_id, language_code)
    if video_transcript:
        return video_transcript.url()
374253
def post_video(self, videoUrl, name=None, ingestMedia=True):
        ''''''
        if name is None:
            name = os.path.basename(videoUrl)

        url = '/videos'
        data = {'name': name}
        new_video = self._make_request(self.CMS_Server, 'POST', url, data=data)
        if ingestMedia:
            self.ingest_video(new_video['id'], videoUrl)
        return new_video
47503
def video(query, opts = {})
      invoke 'Video',
        query,
        opts,
        passthrough_opts: %i(filters sort),
        enum_opt_to_module: {filters: VideoFilter, sort: VideoSort},
        param_name_replacements: {filters: 'VideoFilters', sort: 'VideoSortBy'}
    end
989549
def find_video_by_id(self, video_id):
        
        url = 'https://openapi.youku.com/v2/videos/show_basic.json'
        params = {
            'client_id': self.client_id,
            'video_id': video_id
        }
        r = requests.get(url, params=params)
        check_error(r)
        return r.json()
217399
def _get_videos_for_filter(video_filter, sort_field=None, sort_dir=SortDirection.asc, pagination_conf=None):
    
    videos = Video.objects.filter(**video_filter)
    paginator_context = {}

    if sort_field:
        # Refining by edx_video_id ensures a total order
        videos = videos.order_by(sort_field.value, "edx_video_id")
        if sort_dir == SortDirection.desc:
            videos = videos.reverse()

    if pagination_conf:
        videos_per_page = pagination_conf.get('videos_per_page')
        paginator = Paginator(videos, videos_per_page)
        videos = paginator.page(pagination_conf.get('page_number'))
        paginator_context = {
            'current_page':   videos.number,
            'total_pages': videos.paginator.num_pages,
            'items_on_one_page':videos_per_page
        }

    return (VideoSerializer(video).data for video in videos), paginator_context
1018713
def to_dict(self):
        
        data = {
            'name': self.name,
            'video_id': self.video_id,
            'time': self.time,
            'forceStop': self.force_stop,
            'type': self.type,
            'metadata': self.metadata}
        for key in data.keys():
            if data[key] == None:
                data.pop(key)
        return data
970136
def urlinfo(self, domain, response_group = URLINFO_RESPONSE_GROUPS):
        '''
        
        '''
        params = {
            'Action': "UrlInfo",
            'Url': domain,
            'ResponseGroup': response_group
        }

        url, headers = self.create_v4_signature(params)
        return self.return_output(url, headers)
601297
def get_or_none(cls, **filter_kwargs):
        
        try:
            video = cls.objects.get(**filter_kwargs)
        except cls.DoesNotExist:
            video = None

        return video
666242
def evergreen_video(self, **kwargs):
        """"""
        eqs = self.evergreen(**kwargs)
        eqs = eqs.filter(VideohubVideo())
        return eqs
1220695
def _http(self):
        
        if self._http_internal is None:
            self._http_internal = google.auth.transport.requests.AuthorizedSession(
                self._credentials
            )
        return self._http_internal
672486
def sendVideo(self, chat_id, video,
                  duration=None,
                  width=None,
                  height=None,
                  thumb=None,
                  caption=None,
                  parse_mode=None,
                  supports_streaming=None,
                  disable_notification=None,
                  reply_to_message_id=None,
                  reply_markup=None):
        
        p = _strip(locals(), more=['video'])
        return self._api_request_with_file('sendVideo', _rectify(p), 'video', video)
953378
def from_video(self, path):
        
        frames = self.get_video_frames(path)
        self.handle_type(frames)
        return self
413047
def get(video_id)
      params = {:id => video_id, :part => 'snippet,statistics'}
      request = Yourub::REST::Videos.list(self,params)
      Yourub::Result.format(request).first
    end
1192921
def set_video(self, **kwargs):
        
        self.video = {
            'url': kwargs.get('url'),
            'height': kwargs.get('height'),
            'width': kwargs.get('width'),
        }