``pictures`` is a list of mutagen.flac.Picture instances.
196031
def store(self, mutagen_file, pictures):
        
        mutagen_file.clear_pictures()
        for pic in pictures:
            mutagen_file.add_picture(pic)
1375048
def picture(self, row):
        

        template = '_Xn'
        types = (type(None), binary_type, int)

        def guess_type(v):

            try:
                v = text_type(v).strip()
            except ValueError:
                v = binary_type(v).strip()
                #v = v.decode('ascii', 'replace').strip()

            if not bool(v):
                return type(None)

            for t in (float, int, binary_type, text_type):
                try:
                    return type(t(v))
                except:
                    pass

        def p(e):
            tm = t = None

            try:
                t = guess_type(e)
                tm = self.type_map.get(t, t)
                return template[types.index(tm)]
            except ValueError as e:
                raise ValueError("Type '{}'/'{}' not in the types list: {} ({})".format(t, tm, types, e))

        return ''.join(p(e) for e in row)
483894
public function updatePictures($pictures)
    {
        foreach ($pictures as $picture) {
            $image = $this->pictures()->where('id', $picture['id']);

            if ($image->exists()){
               $image->update(['path' => $picture['path']]);
            } else {
               $this->pictures()->create(['path' => $picture['path']]);
            }
        }
    }
43408
def get_list(self, mutagen_file):
        
        return [self.deserialize(item) for item in self.fetch(mutagen_file)]
800791
private void showFolderAlbumFiles(int position) {
        this.mCurrentFolder = position;
        AlbumFolder albumFolder = mAlbumFolders.get(position);
        mView.bindAlbumFolder(albumFolder);
    }
948469
def _generate_examples(self, archive, directory):
    """"""
    reg = re.compile(os.path.join("^%s" % directory, "(?P<label>neg|pos)", ""))
    for path, imdb_f in archive:
      res = reg.match(path)
      if not res:
        continue
      text = imdb_f.read().strip()
      yield {
          "text": text,
          "label": res.groupdict()["label"],
      }
1311817
def _generate_examples(self, data_dir):
    
    corruption = self.builder_config.corruption
    severity = self.builder_config.severity

    images_file = os.path.join(data_dir, _CORRUPTIONS_TO_FILENAMES[corruption])
    labels_file = os.path.join(data_dir, _LABELS_FILENAME)

    with tf.io.gfile.GFile(labels_file, mode='rb') as f:
      labels = np.load(f)

    num_images = labels.shape[0] // 5
    # Labels are stacked 5 times so we can just read the first iteration
    labels = labels[:num_images]

    with tf.io.gfile.GFile(images_file, mode='rb') as f:
      images = np.load(f)

    # Slice images corresponding to correct severity level
    images = images[(severity - 1) * num_images:severity * num_images]

    for image, label in zip(images, labels):
      yield {
          'image': image,
          'label': label,
      }
144974
def images_grouped_by_type(self):
        
        type = -1
        images = []
        for wc in self:
            if wc.type != type:
                if images:
                    yield (type, images)
                role = wc.role
                creators = []
                images.append(wc.image)

        if images:
            yield (type, images)
1050676
def upload_to_picture(instance, filename):
    
    extension = filename.split('.')[-1].lower()
    salt, hash = generate_sha1(instance.id)
    return '%(path)s/%(hash)s.%(extension)s' % {
                'path': getattr(defaults, 
                            'ACCOUNTS_PICTURE_PATH','%s/%s' % (
                                str(instance._meta.app_label), 
                                str(instance._meta.model_name))),
                'hash': hash[:10],
                'extension': extension}
874395
def image_list(name=None, profile=None, **kwargs):
    '''
    
    '''
    conn = _auth(profile, **kwargs)
    return conn.image_list(name)
426920
def _generate_examples(self, imgs_path, csv_path):
    """"""
    with tf.io.gfile.GFile(csv_path) as csv_f:
      reader = csv.DictReader(csv_f)
      # Get keys for each label from csv
      label_keys = reader.fieldnames[5:]
      data = []
      for row in reader:
        # Get image based on indicated path in csv
        name = row["Path"]
        labels = [_LABELS[row[key]] for key in label_keys]
        data.append((name, labels))

    for name, labels in data:
      yield {
          "name": name,
          "image": os.path.join(imgs_path, name),
          "label": labels
      }
1088913
def new_movie_pic(cls, shapes, shape_id, movie_file, x, y, cx, cy,
                      poster_frame_image, mime_type):
        
        return cls(
            shapes, shape_id, movie_file, x, y, cx, cy, poster_frame_image,
            mime_type
        )._pic
        return
33895
def sortForSameExpTime(expTimes, img_paths):  # , excludeSingleImg=True):
    '''
    
    '''
    d = {}
    for e, i in zip(expTimes, img_paths):
        if e not in d:
            d[e] = []
        d[e].append(i)
#     for key in list(d.keys()):
#         if len(d[key]) == 1:
#             print('have only one image of exposure time [%s]' % key)
#             print('--> exclude that one')
#             d.pop(key)
    d = OrderedDict(sorted(d.items()))
    return list(d.keys()), list(d.values())
1090351
def dependent_images(self):
        
        found = []
        for command in self.commands:
            dep = command.dependent_image
            if dep:
                if dep not in found:
                    yield dep
                    found.append(dep)
294062
function srcFiles() {
         return removeDuplicates(configFiles().concat(libFiles()).concat(modelFiles()).concat(srcDataFiles()).concat(codeFiles()));
     }
587506
def multithread_download_photos(photos):
    
    from concurrent import futures
    global counter
    counter = len(photos)
    cpu_num = multiprocessing.cpu_count()
    with futures.ThreadPoolExecutor(max_workers=cpu_num) as executor:
        for photo in photos:
            executor.submit(download_photo, photo)
268254
def imgwriteincr(fn: Path, imgs, imgslice):
    
    if isinstance(imgslice, int):
        if imgslice and not (imgslice % 2000):
            print(f'appending images {imgslice} to {fn}')

    if isinstance(fn, Path):
        # avoid accidental overwriting of source file due to misspecified command line
        assert fn.suffix == '.h5', 'Expecting to write .h5 file'

        with h5py.File(fn, 'r+') as f:
            f['/rawimg'][imgslice, :, :] = imgs
    elif isinstance(fn, h5py.File):
        f['/rawimg'][imgslice, :, :] = imgs
    else:
        raise TypeError(
            f'{fn} must be Path or h5py.File instead of {type(fn)}')