bn = BatchNormalizer(momentum=0.1)
        with UseNormalizer({'BATCH': bn}):
            normalizer = NormalizerContext.current().get_normalizer('BATCH')
            self.assertEquals(bn, normalizer)

            

Reported by Pylint.

              



from caffe2.python.normalizer_context import UseNormalizer, NormalizerContext
from caffe2.python.normalizer import BatchNormalizer
from caffe2.python.layer_test_util import LayersTestCase



            

Reported by Pylint.

              from caffe2.python.layer_test_util import LayersTestCase


class TestNormalizerContext(LayersTestCase):
    def test_normalizer_context(self):
        bn = BatchNormalizer(momentum=0.1)
        with UseNormalizer({'BATCH': bn}):
            normalizer = NormalizerContext.current().get_normalizer('BATCH')
            self.assertEquals(bn, normalizer)

            

Reported by Pylint.

              

class TestNormalizerContext(LayersTestCase):
    def test_normalizer_context(self):
        bn = BatchNormalizer(momentum=0.1)
        with UseNormalizer({'BATCH': bn}):
            normalizer = NormalizerContext.current().get_normalizer('BATCH')
            self.assertEquals(bn, normalizer)

            

Reported by Pylint.

              
class TestNormalizerContext(LayersTestCase):
    def test_normalizer_context(self):
        bn = BatchNormalizer(momentum=0.1)
        with UseNormalizer({'BATCH': bn}):
            normalizer = NormalizerContext.current().get_normalizer('BATCH')
            self.assertEquals(bn, normalizer)

            

Reported by Pylint.

                std::vector<int64_t> data_;
};

TORCH_LIBRARY(_TorchScriptTesting, m) {
  m.class_<FakeTensor>("_MobileNNCFakeTensor")
      .def(torch::init<std::vector<int64_t>>())
      .def("get", &FakeTensor::get)
      .def_pickle(
          [](c10::intrusive_ptr<FakeTensor> self) { // __getstate__

            

Reported by Cppcheck.

                // Load and run the saved model.
  auto loaded_module = _load_for_mobile(ss);
  auto result = loaded_module.forward(inputs);
  EXPECT_TRUE(result.toTensor().equal(3.0 * torch::ones({4, 4})));
  EXPECT_TRUE(result.toTensor().equal(reference.toTensor()));
}

TEST(NNCBackendTest, FakeTensor) {
  script::Module m("m");

            

Reported by FlawFinder.

                auto loaded_module = _load_for_mobile(ss);
  auto result = loaded_module.forward(inputs);
  EXPECT_TRUE(result.toTensor().equal(3.0 * torch::ones({4, 4})));
  EXPECT_TRUE(result.toTensor().equal(reference.toTensor()));
}

TEST(NNCBackendTest, FakeTensor) {
  script::Module m("m");
  auto param_cls = getCustomClass(

            

Reported by FlawFinder.

                // Load and run the saved model.
  auto loaded_module = _load_for_mobile(ss);
  auto result = loaded_module.forward(inputs);
  EXPECT_TRUE(result.toTensor().equal(5.0 * torch::ones({4, 4})));
  EXPECT_TRUE(result.toTensor().equal(reference.toTensor()));
}

} // namespace nnc
} // namespace mobile

            

Reported by FlawFinder.

                auto loaded_module = _load_for_mobile(ss);
  auto result = loaded_module.forward(inputs);
  EXPECT_TRUE(result.toTensor().equal(5.0 * torch::ones({4, 4})));
  EXPECT_TRUE(result.toTensor().equal(reference.toTensor()));
}

} // namespace nnc
} // namespace mobile
} // namespace jit

            

Reported by FlawFinder.

              # @package regularizer_context
# Module caffe2.python.normalizer_context





from caffe2.python import context
from caffe2.python.modifier_context import (

            

Reported by Pylint.

                  provide context to allow param_info to have different normalizers
    """

    def has_normalizer(self, name):
        return self._has_modifier(name)

    def get_normalizer(self, name):
        assert self.has_normalizer(name), (
            "{} normalizer is not provided!".format(name))

            

Reported by Pylint.

                  def has_normalizer(self, name):
        return self._has_modifier(name)

    def get_normalizer(self, name):
        assert self.has_normalizer(name), (
            "{} normalizer is not provided!".format(name))
        return self._get_modifier(name)



            

Reported by Pylint.

                      return self._has_modifier(name)

    def get_normalizer(self, name):
        assert self.has_normalizer(name), (
            "{} normalizer is not provided!".format(name))
        return self._get_modifier(name)


class UseNormalizer(UseModifierBase):

            

Reported by Bandit.

                      return self._get_modifier(name)


class UseNormalizer(UseModifierBase):
    '''
    context class to allow setting the current context.
    Example usage with layer:
        normalizers = {'norm1': norm1, 'norm2': norm2}
        with UseNormalizer(normalizers):

            

Reported by Pylint.

              ## @package optimizer_context
# Module caffe2.python.optimizer_context





from caffe2.python import context
from caffe2.python.modifier_context import (

            

Reported by Pylint.

                  provide context to allow param_info to have different optimizers
    """

    def has_optimizer(self, name):
        return self._has_modifier(name)

    def get_optimizer(self, name):
        assert self.has_optimizer(name), (
            "{} optimizer is not provided!".format(name))

            

Reported by Pylint.

                  def has_optimizer(self, name):
        return self._has_modifier(name)

    def get_optimizer(self, name):
        assert self.has_optimizer(name), (
            "{} optimizer is not provided!".format(name))
        return self._get_modifier(name)



            

Reported by Pylint.

                      return self._has_modifier(name)

    def get_optimizer(self, name):
        assert self.has_optimizer(name), (
            "{} optimizer is not provided!".format(name))
        return self._get_modifier(name)


class UseOptimizer(UseModifierBase):

            

Reported by Bandit.

                      return self._get_modifier(name)


class UseOptimizer(UseModifierBase):
    '''
    context class to allow setting the current context.
    Example usage with brew:
        - with UseOptimizer(optim):
            brew.func

            

Reported by Pylint.

              
// TODO(T96218435): Enable the following tests in OSS.
TEST(IMethodTest, CallMethod) {
  auto script_model = torch::jit::load(getenv("SIMPLE_JIT"));
  auto script_method = script_model.get_method("forward");

  torch::deploy::InterpreterManager manager(3);
  torch::deploy::Package p = manager.load_package(getenv("SIMPLE"));
  auto py_model = p.load_pickle("model", "model.pkl");

            

Reported by FlawFinder.

                auto script_method = script_model.get_method("forward");

  torch::deploy::InterpreterManager manager(3);
  torch::deploy::Package p = manager.load_package(getenv("SIMPLE"));
  auto py_model = p.load_pickle("model", "model.pkl");
  torch::deploy::PythonMethodWrapper py_method(py_model, "forward");

  auto input = torch::ones({10, 20});
  auto output_py = py_method({input});

            

Reported by FlawFinder.

              }

TEST(IMethodTest, GetArgumentNames) {
  auto scriptModel = torch::jit::load(getenv("SIMPLE_JIT"));
  auto scriptMethod = scriptModel.get_method("forward");

  auto& scriptNames = scriptMethod.getArgumentNames();
  EXPECT_EQ(scriptNames.size(), 1);
  EXPECT_STREQ(scriptNames[0].c_str(), "input");

            

Reported by FlawFinder.

                EXPECT_STREQ(scriptNames[0].c_str(), "input");

  torch::deploy::InterpreterManager manager(3);
  torch::deploy::Package package = manager.load_package(getenv("SIMPLE"));
  auto pyModel = package.load_pickle("model", "model.pkl");
  torch::deploy::PythonMethodWrapper pyMethod(pyModel, "forward");

  auto& pyNames = pyMethod.getArgumentNames();
  EXPECT_EQ(pyNames.size(), 1);

            

Reported by FlawFinder.

                auto output_py_tensor = output_py.toTensor();
  auto output_script_tensor = output_script.toTensor();

  EXPECT_TRUE(output_py_tensor.equal(output_script_tensor));
  EXPECT_EQ(output_py_tensor.numel(), 200);
}

TEST(IMethodTest, GetArgumentNames) {
  auto scriptModel = torch::jit::load(getenv("SIMPLE_JIT"));

            

Reported by FlawFinder.

              # flake8: noqa
import torch
from torch.testing._internal.common_utils import TEST_NUMPY
if TEST_NUMPY:
    import numpy as np

# From the docs, there are quite a few ways to create a tensor:
# https://pytorch.org/docs/stable/tensors.html


            

Reported by Pylint.

              # flake8: noqa
import torch
from torch.testing._internal.common_utils import TEST_NUMPY
if TEST_NUMPY:
    import numpy as np

# From the docs, there are quite a few ways to create a tensor:
# https://pytorch.org/docs/stable/tensors.html


            

Reported by Pylint.

              torch.complex(real, imag)

# torch.polar
abs = torch.tensor([1, 2], dtype=torch.float64)
pi = torch.acos(torch.zeros(1)).item() * 2
angle = torch.tensor([pi / 2, 5 * pi / 4], dtype=torch.float64)
torch.polar(abs, angle)

# torch.heaviside

            

Reported by Pylint.

              # flake8: noqa
import torch
from torch.testing._internal.common_utils import TEST_NUMPY
if TEST_NUMPY:
    import numpy as np

# From the docs, there are quite a few ways to create a tensor:
# https://pytorch.org/docs/stable/tensors.html


            

Reported by Pylint.

              
# torch.quantize_per_channel
x = torch.tensor([[-1.0, 0.0], [1.0, 2.0]])
quant = torch.quantize_per_channel(x, torch.tensor([0.1, 0.01]), torch.tensor([10, 0]), 0, torch.quint8)

# torch.dequantize
torch.dequantize(x)

# torch.complex

            

Reported by Pylint.

              #!/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 os
from argparse import Action

            

Reported by Pylint.

              from argparse import Action


class env(Action):
    """
    Gets argument values from ``PET_{dest}`` before defaulting
    to the given ``default`` value. For flags (e.g. ``--standalone``)
    use ``check_env`` instead.


            

Reported by Pylint.

              from argparse import Action


class env(Action):
    """
    Gets argument values from ``PET_{dest}`` before defaulting
    to the given ``default`` value. For flags (e.g. ``--standalone``)
    use ``check_env`` instead.


            

Reported by Pylint.

                      setattr(namespace, self.dest, values)


class check_env(Action):
    """
    For flags, checks whether the env var ``PET_{dest}`` exists
    before defaulting to the given ``default`` value. Equivalent to
    ``store_true`` argparse built-in action except that the argument can
    be omitted from the commandline if the env var is present and has a

            

Reported by Pylint.

                      setattr(namespace, self.dest, values)


class check_env(Action):
    """
    For flags, checks whether the env var ``PET_{dest}`` exists
    before defaulting to the given ``default`` value. Equivalent to
    ``store_true`` argparse built-in action except that the argument can
    be omitted from the commandline if the env var is present and has a

            

Reported by Pylint.

                  supported = True
    len1 = len(dims1)
    len2 = len(dims2)
    numel1 = reduce(lambda x, y: x * y, dims1)
    numel2 = reduce(lambda x, y: x * y, dims2)
    if len1 < len2:
        broadcast = True
        if numel2 != 1:
            supported = False

            

Reported by Pylint.

              from functools import reduce


def maybe_view(tensor, size, check_same_size=True):
    if check_same_size and tensor.size() == size:
        return tensor
    return tensor.contiguous().view(size)



            

Reported by Pylint.

              from functools import reduce


def maybe_view(tensor, size, check_same_size=True):
    if check_same_size and tensor.size() == size:
        return tensor
    return tensor.contiguous().view(size)



            

Reported by Pylint.

                  return tensor.contiguous().view(size)


def maybe_unexpand(tensor, old_size, check_same_size=True):
    if check_same_size and tensor.size() == old_size:
        return tensor
    num_unsqueezed = tensor.dim() - len(old_size)
    expanded_dims = [dim for dim, (expanded, original)
                     in enumerate(zip(tensor.size()[num_unsqueezed:], old_size))

            

Reported by Pylint.

              #     1) Only one element in dims2, such as dims2 = [1, 1]
#     2) dims2 is suffix of dims1, such as dims1 = [2, 3, 4], and dims2 = [3, 4]
# Details can be found here: https://github.com/onnx/onnx/blob/master/docs/Operators.md#Gemm
def check_onnx_broadcast(dims1, dims2):
    broadcast = False
    supported = True
    len1 = len(dims1)
    len2 = len(dims2)
    numel1 = reduce(lambda x, y: x * y, dims1)

            

Reported by Pylint.

                  construct_and_record_rdzv_event,
)

from .api import (
    RendezvousConnectionError,
    RendezvousError,
    RendezvousParameters,
    RendezvousStateError,
)

            

Reported by Pylint.

                  RendezvousParameters,
    RendezvousStateError,
)
from .dynamic_rendezvous import RendezvousBackend, Token
from .utils import _matches_machine_hostname, parse_rendezvous_endpoint

log = logging.getLogger(__name__)



            

Reported by Pylint.

                  RendezvousStateError,
)
from .dynamic_rendezvous import RendezvousBackend, Token
from .utils import _matches_machine_hostname, parse_rendezvous_endpoint

log = logging.getLogger(__name__)


class C10dRendezvousBackend(RendezvousBackend):

            

Reported by Pylint.

              # 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 binascii
import logging
import os

            

Reported by Pylint.

              
        backend = C10dRendezvousBackend(store, params.run_id)

    except Exception as e:
        construct_and_record_rdzv_event(
            message=f"{type(e).__name__}: {str(e)}",
            run_id=params.run_id,
            node_state=NodeState.FAILED,
        )

            

Reported by Pylint.

                const char* kDistDebugOffLogLevel = "OFF";

  std::string parse_env(const char* env_var_name) {
    char* stringValue = std::getenv(env_var_name);
    std::string res = "N/A";
    if (stringValue != nullptr) {
      res = stringValue;
    }
    return res;

            

Reported by FlawFinder.

              } // namespace

std::string sockaddrToString(struct ::sockaddr* addr) {
  char address[INET6_ADDRSTRLEN + 1];
  if (addr->sa_family == AF_INET) {
    struct ::sockaddr_in* s = reinterpret_cast<struct ::sockaddr_in*>(addr);
    SYSCHECK(
        ::inet_ntop(AF_INET, &(s->sin_addr), address, INET_ADDRSTRLEN),
        __output != nullptr)

            

Reported by FlawFinder.

                  } else {
      levelStr = debugLevel.c_str();
      TORCH_CHECK(
        strncmp(levelStr, kDistDebugDetailLogLevel, strlen(kDistDebugDetailLogLevel)) == 0
        || strncmp(levelStr, kDistDebugInfoLogLevel, strlen(kDistDebugInfoLogLevel)) == 0
        || strncmp(levelStr, kDistDebugOffLogLevel, strlen(kDistDebugOffLogLevel)) == 0,
        c10::str(
          "Expected environment variable TORCH_DISTRIBUTED_DEBUG to be one of ",
          kDistDebugDetailLogLevel,

            

Reported by FlawFinder.

                    levelStr = debugLevel.c_str();
      TORCH_CHECK(
        strncmp(levelStr, kDistDebugDetailLogLevel, strlen(kDistDebugDetailLogLevel)) == 0
        || strncmp(levelStr, kDistDebugInfoLogLevel, strlen(kDistDebugInfoLogLevel)) == 0
        || strncmp(levelStr, kDistDebugOffLogLevel, strlen(kDistDebugOffLogLevel)) == 0,
        c10::str(
          "Expected environment variable TORCH_DISTRIBUTED_DEBUG to be one of ",
          kDistDebugDetailLogLevel,
          " ",

            

Reported by FlawFinder.

                    TORCH_CHECK(
        strncmp(levelStr, kDistDebugDetailLogLevel, strlen(kDistDebugDetailLogLevel)) == 0
        || strncmp(levelStr, kDistDebugInfoLogLevel, strlen(kDistDebugInfoLogLevel)) == 0
        || strncmp(levelStr, kDistDebugOffLogLevel, strlen(kDistDebugOffLogLevel)) == 0,
        c10::str(
          "Expected environment variable TORCH_DISTRIBUTED_DEBUG to be one of ",
          kDistDebugDetailLogLevel,
          " ",
          kDistDebugInfoLogLevel,

            

Reported by FlawFinder.