out_samples = swr_convert(swr, &output, out_samples, input, in_samples);
      auto sample_size = out_samples * c->channels * sizeof(float);
      auto buffer = std::make_unique<float[]>(sample_size);
      memcpy(buffer.get(), output, sample_size);
      av_freep(&output);

      unique_ptr<DecodedAudio> audio_sample = make_unique<DecodedAudio>();
      audio_sample->dataSize_ = data_size;
      audio_sample->outSampleSize_ = out_samples * c->channels;

            

Reported by FlawFinder.

                    unsigned char* buffer_rgb_ptr = new unsigned char[clip_size];
      int clip_start = clip_start_positions[i];
      for (int j = 0; j < params.num_of_required_frame_; j++) {
        memcpy(
            buffer_rgb_ptr + j * image_size,
            (unsigned char*)sampledFrames[j + clip_start]->data_.get(),
            image_size * sizeof(unsigned char));
      }
      buffer_rgb.push_back(buffer_rgb_ptr);

            

Reported by FlawFinder.

                    unsigned char* buffer_rgb_ptr = new unsigned char[clip_size];
      int clip_start = floor(i * sample_stepsz);
      for (int j = 0; j < params.num_of_required_frame_; j++) {
        memcpy(
            buffer_rgb_ptr + j * image_size,
            (unsigned char*)sampledFrames[j + clip_start]->data_.get(),
            image_size * sizeof(unsigned char));
      }
      buffer_rgb.push_back(buffer_rgb_ptr);

            

Reported by FlawFinder.

                  int probeSz = 1 * 1024 + AVPROBE_PADDING_SIZE;
    DecodedFrame::AvDataPtr probe((uint8_t*)av_malloc(probeSz));
    memset(probe.get(), 0, probeSz);
    int len = ioctx.read(probe.get(), probeSz - AVPROBE_PADDING_SIZE);
    if (len < probeSz - AVPROBE_PADDING_SIZE) {
      LOG(ERROR) << "Insufficient data to determine video format";
      return;
    }
    // seek back to start of stream

            

Reported by FlawFinder.

              #!/usr/bin/env python3

# Copyright (c) Facebook, Inc. and its affiliates.
# All rights reserved.
#
# This source code is licensed under the BSD-style license found in the
# LICENSE file in the root directory of this source tree.

import argparse

            

Reported by Pylint.

              from pathlib import Path


def parse_args():
    parser = argparse.ArgumentParser(description="test script")

    parser.add_argument(
        "--fail",
        default=False,

            

Reported by Pylint.

                  return parser.parse_args()


def main():
    args = parse_args()
    env_vars = [
        "LOCAL_RANK",
        "RANK",
        "GROUP_RANK",

            

Reported by Pylint.

                      value = os.environ[env_var]
        print(f"{env_var} = {value}")

    if args.fail:
        raise RuntimeError("raising exception since --fail flag was set")
    else:
        file = os.path.join(args.touch_file_dir, os.environ["RANK"])
        Path(file).touch()
        print(f"Success, created {file}")

            

Reported by Pylint.

                  if (pos >= serialized.size()) return 0;
    size_t nbytes = std::min(static_cast<size_t>(pos) + n,
                             serialized.size()) - pos;
    memcpy(buf, serialized.data() + pos, nbytes);
    return nbytes;
  },
  [&]() -> size_t { return serialized.size(); });
  ASSERT_TRUE(z.defined());
  ASSERT_EQ(x.sizes().vec(), z.sizes().vec());

            

Reported by FlawFinder.

              
  ASSERT_TRUE(lhs_params.size() == rhs_params.size());
  for (size_t j = 0; j < lhs_params.size(); j++) {
    ASSERT_TRUE(torch::equal(lhs_params[j], rhs_params[j]));
  }
  ASSERT_TRUE(static_cast<const DerivedOptions&>(lhs.options()) == static_cast<const DerivedOptions&>(rhs.options()));
}

template <typename DerivedOptimizerParamState>

            

Reported by FlawFinder.

                torch::serialize::InputArchive input_archive;
  input_archive.load_from(tempfile.name);
  c10::IValue ivalue_out;
  input_archive.read("value", ivalue_out);
  ASSERT_EQ(ivalue_out.toInt(), 1);

  ASSERT_THROWS_WITH(input_archive.read("bad_key", ivalue_out), "does not have a field with name");
}


            

Reported by FlawFinder.

                input_archive.read("value", ivalue_out);
  ASSERT_EQ(ivalue_out.toInt(), 1);

  ASSERT_THROWS_WITH(input_archive.read("bad_key", ivalue_out), "does not have a field with name");
}

// NOTE: if a `Module` contains unserializable submodules (e.g. `nn::Functional`),
// we expect those submodules to be skipped when the `Module` is being serialized.
TEST(SerializeTest, UnserializableSubmoduleIsSkippedWhenSavingModule) {

            

Reported by FlawFinder.

                    const T* X,                                                 \
      T* Y,                                                       \
      CPUContext* context) {                                      \
    std::memcpy(Y, X, sizeof(T) * cols);                          \
    for (int i = 1; i < rows; ++i) {                              \
      MathFunc<T, CPUContext>(cols, Y, X + i * cols, Y, context); \
    }                                                             \
    Scale<T, T, CPUContext>(cols, alpha, Y, Y, context);          \
  }

            

Reported by FlawFinder.

                  return;
  }
  if (std::equal(X_dims, X_dims + ndim, Y_dims)) {
    std::memcpy(mean, X, sizeof(T) * Y_size);
    std::memset(var, 0, sizeof(T) * Y_size);
    return;
  }
  // NOLINTNEXTLINE(cppcoreguidelines-init-variables)
  int rows;

            

Reported by FlawFinder.

                  std::memset(var, 0, sizeof(T) * Y_size);
    return;
  }
  if (std::equal(X_dims, X_dims + ndim, Y_dims)) {
    std::memcpy(mean, X, sizeof(T) * Y_size);
    std::memset(var, 0, sizeof(T) * Y_size);
    return;
  }
  // NOLINTNEXTLINE(cppcoreguidelines-init-variables)

            

Reported by FlawFinder.

                    std::memset(Y, 0, sizeof(T) * Y_size);                               \
      return;                                                              \
    }                                                                      \
    if (std::equal(X_dims, X_dims + ndim, Y_dims)) {                       \
      if (kIsNorm) {                                                       \
        EigenVectorArrayMap<T>(Y, Y_size) =                                \
            ConstEigenVectorArrayMap<T>(X, X_size).abs() * alpha;          \
      } else {                                                             \
        Scale<T, T, CPUContext>(Y_size, alpha, X, Y, context);             \

            

Reported by FlawFinder.

              

import argparse
import datetime

import numpy as np
from caffe2.python import core, workspace



            

Reported by Pylint.

              }


def benchmark_sparse_lengths_sum(
    dtype_str,
    categorical_limit,
    embedding_size,
    average_len,
    batch_size,

            

Reported by Pylint.

              }


def benchmark_sparse_lengths_sum(
    dtype_str,
    categorical_limit,
    embedding_size,
    average_len,
    batch_size,

            

Reported by Pylint.

              
    # In order to produce truly random lengths and indices, we will embed a
    # Python operator in the net to generate them.
    def f(_, outputs):
        lengths = np.random.randint(
            int(np.round(average_len * 0.75)),
            int(np.round(average_len * 1.25)) + 1,
            batch_size,
        ).astype(np.int32)

            

Reported by Pylint.

              




import unittest

import torch
from caffe2.python import core, workspace

            

Reported by Pylint.

              # initialization and thus we should be the ones calling GlobalInit
@unittest.skipIf(not workspace.has_cuda_support,
                 "THC pool testing is obscure and doesn't work on HIP yet")
class TestGPUInit(unittest.TestCase):
    def testTHCAllocator(self):
        cuda_or_hip = 'hip' if workspace.has_hip_support else 'cuda'
        flag = '--caffe2_{}_memory_pool=thc'.format(cuda_or_hip)
        core.GlobalInit(['caffe2', flag])
        # just run one operator

            

Reported by Pylint.

              @unittest.skipIf(not workspace.has_cuda_support,
                 "THC pool testing is obscure and doesn't work on HIP yet")
class TestGPUInit(unittest.TestCase):
    def testTHCAllocator(self):
        cuda_or_hip = 'hip' if workspace.has_hip_support else 'cuda'
        flag = '--caffe2_{}_memory_pool=thc'.format(cuda_or_hip)
        core.GlobalInit(['caffe2', flag])
        # just run one operator
        # it's importantant to not call anything here from Torch API

            

Reported by Pylint.

              @unittest.skipIf(not workspace.has_cuda_support,
                 "THC pool testing is obscure and doesn't work on HIP yet")
class TestGPUInit(unittest.TestCase):
    def testTHCAllocator(self):
        cuda_or_hip = 'hip' if workspace.has_hip_support else 'cuda'
        flag = '--caffe2_{}_memory_pool=thc'.format(cuda_or_hip)
        core.GlobalInit(['caffe2', flag])
        # just run one operator
        # it's importantant to not call anything here from Torch API

            

Reported by Pylint.

              import sys
from pathlib import Path

from mypy.plugin import Plugin


def get_correct_mypy_version():
    # there's probably a more elegant way to do this
    match, = re.finditer(

            

Reported by Pylint.

              import re
import sys
from pathlib import Path

from mypy.plugin import Plugin


def get_correct_mypy_version():
    # there's probably a more elegant way to do this

            

Reported by Pylint.

              from mypy.plugin import Plugin


def get_correct_mypy_version():
    # there's probably a more elegant way to do this
    match, = re.finditer(
        r'mypy==(\d+(?:\.\d+)*)',
        Path('.circleci/docker/common/install_conda.sh').read_text(),
    )

            

Reported by Pylint.

                  return version


def plugin(version: str):
    correct_version = get_correct_mypy_version()
    if version != correct_version:
        print(f'''\
You are using mypy version {version}, which is not supported
in the PyTorch repo. Please switch to mypy version {correct_version}.

            

Reported by Pylint.

                  ASSERT_TRUE(indices[5].slice().stop() == INDEX_MAX);
    ASSERT_TRUE(indices[5].slice().step() == 2);
    ASSERT_TRUE(indices[6].is_tensor());
    ASSERT_TRUE(torch::equal(indices[6].tensor(), torch::tensor({1, 2})));
  }

  ASSERT_THROWS_WITH(
    TensorIndex(".."),
    "Expected \"...\" to represent an ellipsis index, but got \"..\"");

            

Reported by FlawFinder.

                  torch::Tensor index = torch::arange(10, torch::kLong).cpu();
    torch::Tensor result = at::index(tensor, {index});
    torch::Tensor result_with_init_list = tensor.index({index});
    ASSERT_TRUE(result.equal(result_with_init_list));
  }
  {
    torch::Tensor tensor = torch::randn({20, 20});
    torch::Tensor index = torch::arange(10, torch::kLong).cpu();
    torch::Tensor result = at::index_put_(tensor, {index}, torch::ones({20}));

            

Reported by FlawFinder.

                  torch::Tensor index = torch::arange(10, torch::kLong).cpu();
    torch::Tensor result = at::index_put_(tensor, {index}, torch::ones({20}));
    torch::Tensor result_with_init_list = tensor.index_put_({index}, torch::ones({20}));
    ASSERT_TRUE(result.equal(result_with_init_list));
  }
  {
    torch::Tensor tensor = torch::randn({20, 20});
    torch::Tensor index = torch::arange(10, torch::kLong).cpu();
    torch::Tensor result = at::index_put_(tensor, {index}, torch::ones({1, 20}));

            

Reported by FlawFinder.

                  torch::Tensor index = torch::arange(10, torch::kLong).cpu();
    torch::Tensor result = at::index_put_(tensor, {index}, torch::ones({1, 20}));
    torch::Tensor result_with_init_list = tensor.index_put_({index}, torch::ones({1, 20}));
    ASSERT_TRUE(result.equal(result_with_init_list));
  }
}

TEST(TensorIndexingTest, TestSingleInt) {
  auto v = torch::randn({5, 7, 3});

            

Reported by FlawFinder.

              from collections import namedtuple

import numpy as np
from caffe2.python import core, workspace
from caffe2.python.test_util import TestCase


class TestConcatOpCost(TestCase):
    def test_columnwise_concat(self):

            

Reported by Pylint.

              from caffe2.python.test_util import TestCase


class TestConcatOpCost(TestCase):
    def test_columnwise_concat(self):
        workspace.ResetWorkspace()
        workspace.FeedBlob("input_1", np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int32))
        workspace.FeedBlob("input_2", np.array([[7], [8]], dtype=np.int32))
        concat_op = core.CreateOperator(

            

Reported by Pylint.

              

class TestConcatOpCost(TestCase):
    def test_columnwise_concat(self):
        workspace.ResetWorkspace()
        workspace.FeedBlob("input_1", np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int32))
        workspace.FeedBlob("input_2", np.array([[7], [8]], dtype=np.int32))
        concat_op = core.CreateOperator(
            "Concat",

            

Reported by Pylint.

                          sum(workspace.FetchBlob(b).nbytes for b in concat_op.output),
        )

    def test_split_then_concat(self):
        workspace.ResetWorkspace()
        workspace.FeedBlob("input", np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int32))
        workspace.FeedBlob("split", np.array([1, 1, 1], dtype=np.int32))
        split_op = core.CreateOperator(
            "Split",

            

Reported by Pylint.

              """

import os.path
import torch.nn.modules.activation
import torch.autograd
import matplotlib

matplotlib.use('Agg')


            

Reported by Pylint.

              
import os.path
import torch.nn.modules.activation
import torch.autograd
import matplotlib

matplotlib.use('Agg')

import pylab

            

Reported by Pylint.

              ]


def plot_function(function, **args):
    """
    Plot a function on the current plot. The additional arguments may
    be used to specify color, alpha, etc.
    """
    xrange = torch.arange(-7.0, 7.0, 0.01)  # We need to go beyond 6 for ReLU6

            

Reported by Pylint.

              
matplotlib.use('Agg')

import pylab


# Create a directory for the images, if it doesn't exist
ACTIVATION_IMAGE_PATH = os.path.join(
    os.path.realpath(os.path.join(__file__, "..")),

            

Reported by Pylint.