in blob[i1]
    """

    def __init__(self, blobs, logging_frequency, i1=0, i2=0):
        self._blobs = blobs
        self._logging_frequency = logging_frequency
        self._i1 = i1
        self._i2 = i2
        self._field_name_suffix = '_{0}_{1}'.format(i1, i2) if i2 >= 0 \

            

Reported by Pylint.

                      self._field_name_suffix = '_{0}_{1}'.format(i1, i2) if i2 >= 0 \
            else '_{0}_all'.format(i1)

    def modify_net(self, net, init_net=None, grad_map=None, blob_to_device=None,
                    modify_output_record=False):

        i1, i2 = [self._i1, self._i2]
        if i1 < 0:
            raise ValueError('index is out of range')

            

Reported by Pylint.

              # Copyright (c) 2016-present, Facebook, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software

            

Reported by Pylint.

                      self._field_name_suffix = '_{0}_{1}'.format(i1, i2) if i2 >= 0 \
            else '_{0}_all'.format(i1)

    def modify_net(self, net, init_net=None, grad_map=None, blob_to_device=None,
                    modify_output_record=False):

        i1, i2 = [self._i1, self._i2]
        if i1 < 0:
            raise ValueError('index is out of range')

            

Reported by Pylint.

                  def modify_net(self, net, init_net=None, grad_map=None, blob_to_device=None,
                    modify_output_record=False):

        i1, i2 = [self._i1, self._i2]
        if i1 < 0:
            raise ValueError('index is out of range')

        for blob_name in self._blobs:
            blob = core.BlobReference(blob_name)

            

Reported by Pylint.

                  def modify_net(self, net, init_net=None, grad_map=None, blob_to_device=None,
                    modify_output_record=False):

        i1, i2 = [self._i1, self._i2]
        if i1 < 0:
            raise ValueError('index is out of range')

        for blob_name in self._blobs:
            blob = core.BlobReference(blob_name)

            

Reported by Pylint.

              
        for blob_name in self._blobs:
            blob = core.BlobReference(blob_name)
            assert net.BlobIsDefined(blob), 'blob {} is not defined in net {} whose proto is {}'.format(blob, net.Name(), net.Proto())

            blob_i1 = net.Slice([blob], starts=[i1, 0], ends=[i1 + 1, -1])
            if self._i2 == -1:
                blob_i1_i2 = net.Copy([blob_i1],
                    [net.NextScopedBlob(prefix=blob + '_{0}_all'.format(i1))])

            

Reported by Pylint.

              
        for blob_name in self._blobs:
            blob = core.BlobReference(blob_name)
            assert net.BlobIsDefined(blob), 'blob {} is not defined in net {} whose proto is {}'.format(blob, net.Name(), net.Proto())

            blob_i1 = net.Slice([blob], starts=[i1, 0], ends=[i1 + 1, -1])
            if self._i2 == -1:
                blob_i1_i2 = net.Copy([blob_i1],
                    [net.NextScopedBlob(prefix=blob + '_{0}_all'.format(i1))])

            

Reported by Bandit.

                              else:
                    net.AppendOutputRecordField(output_field_name, output_scalar)

    def field_name_suffix(self):
        return self._field_name_suffix

            

Reported by Pylint.

                      accumulate: boolean to output accumulate or per-batch histogram
    """

    def __init__(self, blobs, logging_frequency, num_buckets=30,
            lower_bound=0.0, upper_bound=1.0, accumulate=False):
        self._blobs = blobs
        self._logging_frequency = logging_frequency
        self._accumulate = accumulate
        if self._accumulate:

            

Reported by Pylint.

                      self._lower_bound = float(lower_bound)
        self._upper_bound = float(upper_bound)

    def modify_net(self, net, init_net=None, grad_map=None, blob_to_device=None,
                   modify_output_record=False):
        for blob_name in self._blobs:
            blob = core.BlobReference(blob_name)
            assert net.BlobIsDefined(blob), 'blob {} is not defined in net {} whose proto is {}'.format(blob, net.Name(), net.Proto())


            

Reported by Pylint.

              




from caffe2.python import core, schema
from caffe2.python.modeling.net_modifier import NetModifier

import numpy as np

            

Reported by Pylint.

                      accumulate: boolean to output accumulate or per-batch histogram
    """

    def __init__(self, blobs, logging_frequency, num_buckets=30,
            lower_bound=0.0, upper_bound=1.0, accumulate=False):
        self._blobs = blobs
        self._logging_frequency = logging_frequency
        self._accumulate = accumulate
        if self._accumulate:

            

Reported by Pylint.

                          self._field_name_suffix = '_curr_normalized_hist'

        self._num_buckets = int(num_buckets)
        assert self._num_buckets > 0, (
            "num_buckets need to be greater than 0, got {}".format(num_buckets))
        self._lower_bound = float(lower_bound)
        self._upper_bound = float(upper_bound)

    def modify_net(self, net, init_net=None, grad_map=None, blob_to_device=None,

            

Reported by Bandit.

                      self._lower_bound = float(lower_bound)
        self._upper_bound = float(upper_bound)

    def modify_net(self, net, init_net=None, grad_map=None, blob_to_device=None,
                   modify_output_record=False):
        for blob_name in self._blobs:
            blob = core.BlobReference(blob_name)
            assert net.BlobIsDefined(blob), 'blob {} is not defined in net {} whose proto is {}'.format(blob, net.Name(), net.Proto())


            

Reported by Pylint.

                                 modify_output_record=False):
        for blob_name in self._blobs:
            blob = core.BlobReference(blob_name)
            assert net.BlobIsDefined(blob), 'blob {} is not defined in net {} whose proto is {}'.format(blob, net.Name(), net.Proto())

            blob_float = net.Cast(blob, net.NextScopedBlob(prefix=blob +
                '_float'), to=core.DataType.FLOAT)
            curr_hist, acc_hist = net.AccumulateHistogram(
                [blob_float],

            

Reported by Bandit.

                                 modify_output_record=False):
        for blob_name in self._blobs:
            blob = core.BlobReference(blob_name)
            assert net.BlobIsDefined(blob), 'blob {} is not defined in net {} whose proto is {}'.format(blob, net.Name(), net.Proto())

            blob_float = net.Cast(blob, net.NextScopedBlob(prefix=blob +
                '_float'), to=core.DataType.FLOAT)
            curr_hist, acc_hist = net.AccumulateHistogram(
                [blob_float],

            

Reported by Pylint.

                                      output_field_name,
                        output_scalar)

    def field_name_suffix(self):
        return self._field_name_suffix

            

Reported by Pylint.

              import argparse

import torch

import benchmark_core
import benchmark_utils

"""Performance microbenchmarks's main binary.


            

Reported by Pylint.

              
import torch

import benchmark_core
import benchmark_utils

"""Performance microbenchmarks's main binary.

This is the main function for running performance microbenchmark tests.

            

Reported by Pylint.

              import torch

import benchmark_core
import benchmark_utils

"""Performance microbenchmarks's main binary.

This is the main function for running performance microbenchmark tests.
It also registers existing benchmark tests via Python module imports.

            

Reported by Pylint.

              import benchmark_core
import benchmark_utils

"""Performance microbenchmarks's main binary.

This is the main function for running performance microbenchmark tests.
It also registers existing benchmark tests via Python module imports.
"""
parser = argparse.ArgumentParser(

            

Reported by Pylint.

              import argparse

import torch

import benchmark_core
import benchmark_utils

"""Performance microbenchmarks's main binary.


            

Reported by Pylint.

                  formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)

def parse_args():
    parser.add_argument(
        '--tag_filter',
        help='tag_filter can be used to run the shapes which matches the tag. (all is used to run all the shapes)',
        default='short')


            

Reported by Pylint.

              def parse_args():
    parser.add_argument(
        '--tag_filter',
        help='tag_filter can be used to run the shapes which matches the tag. (all is used to run all the shapes)',
        default='short')

    # This option is used to filter test cases to run.
    parser.add_argument(
        '--operators',

            

Reported by Pylint.

              
    parser.add_argument(
        "--num_runs",
        help="Run each test for num_runs. Each run executes an operator for number of <--iterations>",
        type=int,
        default=1,
    )

    parser.add_argument(

            

Reported by Pylint.

              
    return args

def main():
    args = parse_args()
    benchmark_core.BenchmarkRunner(args).run()


if __name__ == "__main__":

            

Reported by Pylint.

                std::vector<char> pixels(rows * cols);
  int count = 0;
  const int kMaxKeyLength = 11;
  char key_cstr[kMaxKeyLength];

  TensorProtos protos;
  TensorProto* data = protos.add_protos();
  TensorProto* label = protos.add_protos();
  data->set_data_type(TensorProto::BYTE);

            

Reported by FlawFinder.

                uint32_t rows;
  uint32_t cols;

  image_file.read(reinterpret_cast<char*>(&magic), 4);
  magic = swap_endian(magic);
  if (magic == 529205256) {
    LOG(FATAL) <<
        "It seems that you forgot to unzip the mnist dataset. You should "
        "first unzip them using e.g. gunzip on Linux.";

            

Reported by FlawFinder.

                      "first unzip them using e.g. gunzip on Linux.";
  }
  CAFFE_ENFORCE_EQ(magic, 2051, "Incorrect image file magic.");
  label_file.read(reinterpret_cast<char*>(&magic), 4);
  magic = swap_endian(magic);
  CAFFE_ENFORCE_EQ(magic, 2049, "Incorrect label file magic.");
  image_file.read(reinterpret_cast<char*>(&num_items), 4);
  num_items = swap_endian(num_items);
  label_file.read(reinterpret_cast<char*>(&num_labels), 4);

            

Reported by FlawFinder.

                label_file.read(reinterpret_cast<char*>(&magic), 4);
  magic = swap_endian(magic);
  CAFFE_ENFORCE_EQ(magic, 2049, "Incorrect label file magic.");
  image_file.read(reinterpret_cast<char*>(&num_items), 4);
  num_items = swap_endian(num_items);
  label_file.read(reinterpret_cast<char*>(&num_labels), 4);
  num_labels = swap_endian(num_labels);
  CAFFE_ENFORCE_EQ(num_items, num_labels);
  image_file.read(reinterpret_cast<char*>(&rows), 4);

            

Reported by FlawFinder.

                CAFFE_ENFORCE_EQ(magic, 2049, "Incorrect label file magic.");
  image_file.read(reinterpret_cast<char*>(&num_items), 4);
  num_items = swap_endian(num_items);
  label_file.read(reinterpret_cast<char*>(&num_labels), 4);
  num_labels = swap_endian(num_labels);
  CAFFE_ENFORCE_EQ(num_items, num_labels);
  image_file.read(reinterpret_cast<char*>(&rows), 4);
  rows = swap_endian(rows);
  image_file.read(reinterpret_cast<char*>(&cols), 4);

            

Reported by FlawFinder.

                label_file.read(reinterpret_cast<char*>(&num_labels), 4);
  num_labels = swap_endian(num_labels);
  CAFFE_ENFORCE_EQ(num_items, num_labels);
  image_file.read(reinterpret_cast<char*>(&rows), 4);
  rows = swap_endian(rows);
  image_file.read(reinterpret_cast<char*>(&cols), 4);
  cols = swap_endian(cols);

  // leveldb

            

Reported by FlawFinder.

                CAFFE_ENFORCE_EQ(num_items, num_labels);
  image_file.read(reinterpret_cast<char*>(&rows), 4);
  rows = swap_endian(rows);
  image_file.read(reinterpret_cast<char*>(&cols), 4);
  cols = swap_endian(cols);

  // leveldb
  std::unique_ptr<db::DB> mnist_db(db::CreateDB(FLAGS_db, db_path, db::NEW));
  std::unique_ptr<db::Transaction> transaction(mnist_db->NewTransaction());

            

Reported by FlawFinder.

                LOG(INFO) << "A total of " << num_items << " items.";
  LOG(INFO) << "Rows: " << rows << " Cols: " << cols;
  for (int item_id = 0; item_id < num_items; ++item_id) {
    image_file.read(pixels.data(), rows * cols);
    label_file.read(&label_value, 1);
    for (int i = 0; i < rows * cols; ++i) {
      data->set_byte_data(pixels.data(), rows * cols);
    }
    label->set_int32_data(0, static_cast<int>(label_value));

            

Reported by FlawFinder.

                LOG(INFO) << "Rows: " << rows << " Cols: " << cols;
  for (int item_id = 0; item_id < num_items; ++item_id) {
    image_file.read(pixels.data(), rows * cols);
    label_file.read(&label_value, 1);
    for (int i = 0; i < rows * cols; ++i) {
      data->set_byte_data(pixels.data(), rows * cols);
    }
    label->set_int32_data(0, static_cast<int>(label_value));
    snprintf(key_cstr, kMaxKeyLength, "%08d", item_id);

            

Reported by FlawFinder.

              

class Tags(object):
    # TODO(amalevich): Tags might need to live in their own contexts, add this
    # split later
    EXCLUDE_FROM_TRAIN = 'exclude_from_train'
    EXCLUDE_FROM_EVAL = 'exclude_from_eval'
    EXCLUDE_FROM_PREDICTION = 'exclude_from_prediction'
    EXCLUDE_FROM_ACCUMULATE_PRED = 'exclude_from_accumulate_pred'

            

Reported by Pylint.

                  """
    Valid tag prefixes for distributed training framework.
    """
    """
    Used to pass on info to the 'extra_info' field in the net
    Proto. Typically to provide info for distributed training.
    """
    EXTRA_INFO = 'extra_info:'
    """

            

Reported by Pylint.

                      TagContext.current().add_tags(self.tags)
        return self

    def __exit__(self, type, value, traceback):
        TagContext.current().remove_tags(self.tags)

    def __call__(self, func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):

            

Reported by Pylint.

              ## @package tags
# Module caffe2.python.layers.tags





import functools


            

Reported by Pylint.

                      # Tags is expected to be list to keep order of adding/removing things
        self.tags = tags or []

    def add_tags(self, tags):
        self.tags.extend(tags)

    def remove_tags(self, tags):
        assert self.tags[-len(tags):] == tags
        self.tags = self.tags[:-len(tags)]

            

Reported by Pylint.

                  def add_tags(self, tags):
        self.tags.extend(tags)

    def remove_tags(self, tags):
        assert self.tags[-len(tags):] == tags
        self.tags = self.tags[:-len(tags)]


class Tags(object):

            

Reported by Pylint.

                      self.tags.extend(tags)

    def remove_tags(self, tags):
        assert self.tags[-len(tags):] == tags
        self.tags = self.tags[:-len(tags)]


class Tags(object):
    # TODO(amalevich): Tags might need to live in their own contexts, add this

            

Reported by Bandit.

                      self.tags = self.tags[:-len(tags)]


class Tags(object):
    # TODO(amalevich): Tags might need to live in their own contexts, add this
    # split later
    EXCLUDE_FROM_TRAIN = 'exclude_from_train'
    EXCLUDE_FROM_EVAL = 'exclude_from_eval'
    EXCLUDE_FROM_PREDICTION = 'exclude_from_prediction'

            

Reported by Pylint.

                      self.tags = self.tags[:-len(tags)]


class Tags(object):
    # TODO(amalevich): Tags might need to live in their own contexts, add this
    # split later
    EXCLUDE_FROM_TRAIN = 'exclude_from_train'
    EXCLUDE_FROM_EVAL = 'exclude_from_eval'
    EXCLUDE_FROM_PREDICTION = 'exclude_from_prediction'

            

Reported by Pylint.

              import tensorboard
from setuptools import distutils

LooseVersion = distutils.version.LooseVersion

if not hasattr(tensorboard, '__version__') or LooseVersion(tensorboard.__version__) < LooseVersion('1.15'):
    raise ImportError('TensorBoard logging requires TensorBoard version 1.15 or above')

del distutils

            

Reported by Pylint.

              del LooseVersion
del tensorboard

from .writer import FileWriter, SummaryWriter  # noqa: F401
from tensorboard.summary.writer.record_writer import RecordWriter  # noqa: F401

            

Reported by Pylint.

              del tensorboard

from .writer import FileWriter, SummaryWriter  # noqa: F401
from tensorboard.summary.writer.record_writer import RecordWriter  # noqa: F401

            

Reported by Pylint.

              import tensorboard
from setuptools import distutils

LooseVersion = distutils.version.LooseVersion

if not hasattr(tensorboard, '__version__') or LooseVersion(tensorboard.__version__) < LooseVersion('1.15'):
    raise ImportError('TensorBoard logging requires TensorBoard version 1.15 or above')

del distutils

            

Reported by Pylint.

              import tensorboard
from setuptools import distutils

LooseVersion = distutils.version.LooseVersion

if not hasattr(tensorboard, '__version__') or LooseVersion(tensorboard.__version__) < LooseVersion('1.15'):
    raise ImportError('TensorBoard logging requires TensorBoard version 1.15 or above')

del distutils

            

Reported by Pylint.

              
LooseVersion = distutils.version.LooseVersion

if not hasattr(tensorboard, '__version__') or LooseVersion(tensorboard.__version__) < LooseVersion('1.15'):
    raise ImportError('TensorBoard logging requires TensorBoard version 1.15 or above')

del distutils
del LooseVersion
del tensorboard

            

Reported by Pylint.

              del LooseVersion
del tensorboard

from .writer import FileWriter, SummaryWriter  # noqa: F401
from tensorboard.summary.writer.record_writer import RecordWriter  # noqa: F401

            

Reported by Pylint.

              del tensorboard

from .writer import FileWriter, SummaryWriter  # noqa: F401
from tensorboard.summary.writer.record_writer import RecordWriter  # noqa: F401

            

Reported by Pylint.

              del tensorboard

from .writer import FileWriter, SummaryWriter  # noqa: F401
from tensorboard.summary.writer.record_writer import RecordWriter  # noqa: F401

            

Reported by Pylint.

              import collections


Entry = collections.namedtuple('Entry', 'version, hash')


def update_hash(seed, value):
    # Good old boost::hash_combine
    # https://www.boost.org/doc/libs/1_35_0/doc/html/boost/hash_combine_id241013.html

            

Reported by Pylint.

              Entry = collections.namedtuple('Entry', 'version, hash')


def update_hash(seed, value):
    # Good old boost::hash_combine
    # https://www.boost.org/doc/libs/1_35_0/doc/html/boost/hash_combine_id241013.html
    return seed ^ (hash(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2))



            

Reported by Pylint.

                  return seed ^ (hash(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2))


def hash_source_files(hash_value, source_files):
    for filename in source_files:
        with open(filename) as file:
            hash_value = update_hash(hash_value, file.read())
    return hash_value


            

Reported by Pylint.

                  return hash_value


def hash_build_arguments(hash_value, build_arguments):
    for group in build_arguments:
        if group:
            for argument in group:
                hash_value = update_hash(hash_value, argument)
    return hash_value

            

Reported by Pylint.

                  return hash_value


class ExtensionVersioner(object):
    def __init__(self):
        self.entries = {}

    def get_version(self, name):
        entry = self.entries.get(name)

            

Reported by Pylint.

                  return hash_value


class ExtensionVersioner(object):
    def __init__(self):
        self.entries = {}

    def get_version(self, name):
        entry = self.entries.get(name)

            

Reported by Pylint.

                  def __init__(self):
        self.entries = {}

    def get_version(self, name):
        entry = self.entries.get(name)
        return None if entry is None else entry.version

    def bump_version_if_changed(self,
                                name,

            

Reported by Pylint.

                      entry = self.entries.get(name)
        return None if entry is None else entry.version

    def bump_version_if_changed(self,
                                name,
                                source_files,
                                build_arguments,
                                build_directory,
                                with_cuda,

            

Reported by Pylint.

                      entry = self.entries.get(name)
        return None if entry is None else entry.version

    def bump_version_if_changed(self,
                                name,
                                source_files,
                                build_arguments,
                                build_directory,
                                with_cuda,

            

Reported by Pylint.

              
import torch
from torch._six import string_classes
from . import MP_STATUS_CHECK_INTERVAL
from torch._utils import ExceptionWrapper


def _pin_memory_loop(in_queue, out_queue, device_id, done_event):
    # This setting is thread local, and prevents the copy in pin_memory from

            

Reported by Pylint.

              def _pin_memory_loop(in_queue, out_queue, device_id, done_event):
    # This setting is thread local, and prevents the copy in pin_memory from
    # consuming all CPU cores.
    torch.set_num_threads(1)

    torch.cuda.set_device(device_id)

    # See NOTE [ Data Loader Multiprocessing Shutdown Logic ] for details on the
    # logic of this function.

            

Reported by Pylint.

                      if not done_event.is_set() and not isinstance(data, ExceptionWrapper):
            try:
                data = pin_memory(data)
            except Exception:
                data = ExceptionWrapper(
                    where="in pin memory thread for device {}".format(device_id))
            r = (idx, data)
        while not done_event.is_set():
            try:

            

Reported by Pylint.

              import torch
from torch._six import string_classes
from . import MP_STATUS_CHECK_INTERVAL
from torch._utils import ExceptionWrapper


def _pin_memory_loop(in_queue, out_queue, device_id, done_event):
    # This setting is thread local, and prevents the copy in pin_memory from
    # consuming all CPU cores.

            

Reported by Pylint.

                  # logic of this function.
    while not done_event.is_set():
        try:
            r = in_queue.get(timeout=MP_STATUS_CHECK_INTERVAL)
        except queue.Empty:
            continue
        idx, data = r
        if not done_event.is_set() and not isinstance(data, ExceptionWrapper):
            try:

            

Reported by Pylint.

                          except Exception:
                data = ExceptionWrapper(
                    where="in pin memory thread for device {}".format(device_id))
            r = (idx, data)
        while not done_event.is_set():
            try:
                out_queue.put(r, timeout=MP_STATUS_CHECK_INTERVAL)
                break
            except queue.Full:

            

Reported by Pylint.

                      del r  # save memory


def pin_memory(data):
    if isinstance(data, torch.Tensor):
        return data.pin_memory()
    elif isinstance(data, string_classes):
        return data
    elif isinstance(data, collections.abc.Mapping):

            

Reported by Pylint.

                      del r  # save memory


def pin_memory(data):
    if isinstance(data, torch.Tensor):
        return data.pin_memory()
    elif isinstance(data, string_classes):
        return data
    elif isinstance(data, collections.abc.Mapping):

            

Reported by Pylint.

              

def pin_memory(data):
    if isinstance(data, torch.Tensor):
        return data.pin_memory()
    elif isinstance(data, string_classes):
        return data
    elif isinstance(data, collections.abc.Mapping):
        return {k: pin_memory(sample) for k, sample in data.items()}

            

Reported by Pylint.

              

class _MapDatasetFetcher(_BaseDatasetFetcher):
    def __init__(self, dataset, auto_collation, collate_fn, drop_last):
        super(_MapDatasetFetcher, self).__init__(dataset, auto_collation, collate_fn, drop_last)

    def fetch(self, possibly_batched_index):
        if self.auto_collation:
            data = [self.dataset[idx] for idx in possibly_batched_index]

            

Reported by Pylint.

              """


class _BaseDatasetFetcher(object):
    def __init__(self, dataset, auto_collation, collate_fn, drop_last):
        self.dataset = dataset
        self.auto_collation = auto_collation
        self.collate_fn = collate_fn
        self.drop_last = drop_last

            

Reported by Pylint.

              """


class _BaseDatasetFetcher(object):
    def __init__(self, dataset, auto_collation, collate_fn, drop_last):
        self.dataset = dataset
        self.auto_collation = auto_collation
        self.collate_fn = collate_fn
        self.drop_last = drop_last

            

Reported by Pylint.

                      self.collate_fn = collate_fn
        self.drop_last = drop_last

    def fetch(self, possibly_batched_index):
        raise NotImplementedError()


class _IterableDatasetFetcher(_BaseDatasetFetcher):
    def __init__(self, dataset, auto_collation, collate_fn, drop_last):

            

Reported by Pylint.

                      raise NotImplementedError()


class _IterableDatasetFetcher(_BaseDatasetFetcher):
    def __init__(self, dataset, auto_collation, collate_fn, drop_last):
        super(_IterableDatasetFetcher, self).__init__(dataset, auto_collation, collate_fn, drop_last)
        self.dataset_iter = iter(dataset)
        self.ended = False


            

Reported by Pylint.

              
class _IterableDatasetFetcher(_BaseDatasetFetcher):
    def __init__(self, dataset, auto_collation, collate_fn, drop_last):
        super(_IterableDatasetFetcher, self).__init__(dataset, auto_collation, collate_fn, drop_last)
        self.dataset_iter = iter(dataset)
        self.ended = False

    def fetch(self, possibly_batched_index):
        if self.ended:

            

Reported by Pylint.

              
class _IterableDatasetFetcher(_BaseDatasetFetcher):
    def __init__(self, dataset, auto_collation, collate_fn, drop_last):
        super(_IterableDatasetFetcher, self).__init__(dataset, auto_collation, collate_fn, drop_last)
        self.dataset_iter = iter(dataset)
        self.ended = False

    def fetch(self, possibly_batched_index):
        if self.ended:

            

Reported by Pylint.

                      return self.collate_fn(data)


class _MapDatasetFetcher(_BaseDatasetFetcher):
    def __init__(self, dataset, auto_collation, collate_fn, drop_last):
        super(_MapDatasetFetcher, self).__init__(dataset, auto_collation, collate_fn, drop_last)

    def fetch(self, possibly_batched_index):
        if self.auto_collation:

            

Reported by Pylint.

              
class _MapDatasetFetcher(_BaseDatasetFetcher):
    def __init__(self, dataset, auto_collation, collate_fn, drop_last):
        super(_MapDatasetFetcher, self).__init__(dataset, auto_collation, collate_fn, drop_last)

    def fetch(self, possibly_batched_index):
        if self.auto_collation:
            data = [self.dataset[idx] for idx in possibly_batched_index]
        else:

            

Reported by Pylint.

              

def _set_python_exit_flag():
    global python_exit_status
    python_exit_status = True

atexit.register(_set_python_exit_flag)



            

Reported by Pylint.

              atexit.register(_set_python_exit_flag)


from . import worker, signal_handling, pin_memory, collate, fetch

            

Reported by Pylint.

              atexit.register(_set_python_exit_flag)


from . import worker, signal_handling, pin_memory, collate, fetch

            

Reported by Pylint.

              atexit.register(_set_python_exit_flag)


from . import worker, signal_handling, pin_memory, collate, fetch

            

Reported by Pylint.

              atexit.register(_set_python_exit_flag)


from . import worker, signal_handling, pin_memory, collate, fetch

            

Reported by Pylint.

              atexit.register(_set_python_exit_flag)


from . import worker, signal_handling, pin_memory, collate, fetch

            

Reported by Pylint.

                  sender is alive to prevent hanging."""


python_exit_status = False
r"""Whether Python is shutting down. This flag is guaranteed to be set before
the Python core library resources are freed, but Python may already be exiting
for some time when this is set.

Hook to set this flag is `_set_python_exit_flag`, and is inspired by a similar

            

Reported by Pylint.

              

def _set_python_exit_flag():
    global python_exit_status
    python_exit_status = True

atexit.register(_set_python_exit_flag)



            

Reported by Pylint.

              atexit.register(_set_python_exit_flag)


from . import worker, signal_handling, pin_memory, collate, fetch

            

Reported by Pylint.