Sets the movie for this loader to the inputed movie.
        
        :param      movie | <QMovie>
325009
def setMovie( self, movie ):
        
        self._movieLabel.setMovie(movie)
        self._smallMovieLabel.setMovie(movie)
888756
def set_sub_video_stream_type(self, format, callback=None):
        '''
        
        '''
        params = {'format': format}
        return self.execute_command('setSubVideoStreamType',
                                        params, callback=callback)
1006071
def pool(config = {}, &block)
      _ = Celluloid.supervise(pooling_options(config, block: block, actors: self))
      _.actors.last
    end
206296
def setitem(self, key, value):
        
        with self.lock:
            self.tbl[key] = value
559255
def setupMovie(self):
    """"""
    if self.state == self.INIT:
      self.sendRtspRequest(self.SETUP)
946777
def set(self, key, val):
    
    self._create_file_if_none_exists()
    with open(self.filename, 'r+b') as file_object:
      cache_pickle = pickle.load(file_object)
      cache_pickle[key] = val
      file_object.seek(0)
      pickle.dump(cache_pickle, file_object)
1247223
def set(self, media, _bytes, overwrite=True, b64encode=False):
        
        data = base64.b64encode(_bytes) if b64encode else Binary(_bytes)
        self._dokuwiki.send('wiki.putAttachment', media, data, ow=overwrite)
692819
def set_image(self, image, filename=None, resize=False):
        
        if self.id:
            data = self.connection.post('add_image', filename,
                video_id=self.id, image=image.to_dict(), resize=resize)
            if data:
                self.image = Image(data=data)
429521
def SetModel(self, loader):
        """"""
        self.loader = loader
        self.adapter, tree, rows = self.RootNode()
        self.listControl.integrateRecords(rows.values())
        self.activated_node = tree
        self.squareMap.SetModel(tree, self.adapter)
        self.RecordHistory()
303631
def load_movies(data_home, size):
    
    all_genres = ['Action',
                  'Adventure',
                  'Animation',
                  "Children's",
                  'Comedy',
                  'Crime',
                  'Documentary',
                  'Drama',
                  'Fantasy',
                  'Film-Noir',
                  'Horror',
                  'Musical',
                  'Mystery',
                  'Romance',
                  'Sci-Fi',
                  'Thriller',
                  'War',
                  'Western']
    n_genre = len(all_genres)

    movies = {}

    if size == '100k':
        with open(os.path.join(data_home, 'u.item'), encoding='ISO-8859-1') as f:
            lines = list(map(lambda l: l.rstrip().split('|'), f.readlines()))

        for line in lines:
            movie_vec = np.zeros(n_genre)
            for i, flg_chr in enumerate(line[-n_genre:]):
                if flg_chr == '1':
                    movie_vec[i] = 1.
            movie_id = int(line[0])
            movies[movie_id] = movie_vec
    elif size == '1m':
        with open(os.path.join(data_home, 'movies.dat'), encoding='ISO-8859-1') as f:
            lines = list(map(lambda l: l.rstrip().split('::'), f.readlines()))

        for item_id_str, title, genres in lines:
            movie_vec = np.zeros(n_genre)
            for genre in genres.split('|'):
                i = all_genres.index(genre)
                movie_vec[i] = 1.
            item_id = int(item_id_str)
            movies[item_id] = movie_vec

    return movies
898815
def set(self, value):
        

        if not isinstance(value, int_types):
            raise TypeError(unwrap(
                '''
                %s value must be an integer, not %s
                ''',
                type_name(self),
                type_name(value)
            ))

        self._native = value
        self.contents = int_to_bytes(value, signed=False)
        self._header = None
        if self._indefinite:
            self._indefinite = False
            self.method = 0
        if self._trailer != b'':
            self._trailer = b''
465362
def setMovie( self, movie ):
        
        if ( self._movie ):
            self._movie.frameChanged.disconnect(self.updateIcon)
            
        self._movie = movie
        
        if ( self._movie ):
            self._movie.frameChanged.connect(self.updateIcon)
742823
def setMovie(self, column, movie):
        
        curr = self._movies.get(column)
        if curr == movie:
            return True
        else:
            try:
                curr.frameChanged.disconnect(self._updateFrame)
            except StandardError:
                pass
        
        if movie is not None:
            self.requireCleanup()

            self._movies[column] = movie
            self.setIcon(column, QtGui.QIcon(movie.currentPixmap()))
            
            try:
                movie.frameChanged.connect(self._updateFrame,
                                           QtCore.Qt.UniqueConnection)
            except StandardError:
                pass
        else:
            self._movies.pop(column, None)
1193192
def set(self, value):
        

        if not isinstance(value, byte_cls):
            raise TypeError(unwrap(
                '''
                %s value must be a byte string, not %s
                ''',
                type_name(self),
                type_name(value)
            ))

        self._native = value
        self.contents = value
        self._header = None
        if self._trailer != b'':
            self._trailer = b''
378913
public void setFileSize() {
        if (arr[DatenFilm.FILM_GROESSE].isEmpty())
            arr[DatenFilm.FILM_GROESSE] = FileSize.laengeString(arr[DatenFilm.FILM_URL]);
    }
1321896
def set(self, new_value):
        
        return self._encode_invoke(atomic_reference_set_codec,
                                   new_value=self._to_data(new_value))
640128
def fromguess(cls, name, guess):
        
        if guess['type'] == 'episode':
            return Episode.fromguess(name, guess)

        if guess['type'] == 'movie':
            return Movie.fromguess(name, guess)

        raise ValueError('The guess must be an episode or a movie guess')