import numpy as np
from hypothesis import assume, given, settings
import hypothesis.strategies as st

from caffe2.proto import caffe2_pb2
from caffe2.python import core, utils
import caffe2.python.hip_test_util as hiputl

            

Reported by Pylint.

              
import numpy as np
from hypothesis import assume, given, settings
import hypothesis.strategies as st

from caffe2.proto import caffe2_pb2
from caffe2.python import core, utils
import caffe2.python.hip_test_util as hiputl
import caffe2.python.hypothesis_test_util as hu

            

Reported by Pylint.

                          if order == "NHWC":
                assume(group == 1 and engine != "CUDNN")
        else:
            # TODO: Group conv in NHWC not implemented for GPU yet.
            assume(group == 1 or order == "NCHW" or gc.device_type == caffe2_pb2.CPU)

            if group != 1 and order == "NHWC":
                dc = [d for d in dc if d.device_type == caffe2_pb2.CPU]


            

Reported by Pylint.

              



import numpy as np
from hypothesis import assume, given, settings
import hypothesis.strategies as st

from caffe2.proto import caffe2_pb2

            

Reported by Pylint.

              import caffe2.python.hip_test_util as hiputl
import caffe2.python.hypothesis_test_util as hu

import unittest

class TestGroupConvolution(hu.HypothesisTestCase):

    @given(stride=st.integers(1, 3),
           pad=st.integers(0, 3),

            

Reported by Pylint.

              
import unittest

class TestGroupConvolution(hu.HypothesisTestCase):

    @given(stride=st.integers(1, 3),
           pad=st.integers(0, 3),
           kernel=st.integers(1, 5),
           size=st.integers(7, 10),

            

Reported by Pylint.

                         use_bias=st.booleans(),
           **hu.gcs)
    @settings(max_examples=2, deadline=None)
    def test_group_convolution(
            self, stride, pad, kernel, size, group,
            input_channels_per_group, output_channels_per_group, batch_size,
            order, engine, use_bias, gc, dc):
        assume(size >= kernel)


            

Reported by Pylint.

                         use_bias=st.booleans(),
           **hu.gcs)
    @settings(max_examples=2, deadline=None)
    def test_group_convolution(
            self, stride, pad, kernel, size, group,
            input_channels_per_group, output_channels_per_group, batch_size,
            order, engine, use_bias, gc, dc):
        assume(size >= kernel)


            

Reported by Pylint.

                         use_bias=st.booleans(),
           **hu.gcs)
    @settings(max_examples=2, deadline=None)
    def test_group_convolution(
            self, stride, pad, kernel, size, group,
            input_channels_per_group, output_channels_per_group, batch_size,
            order, engine, use_bias, gc, dc):
        assume(size >= kernel)


            

Reported by Pylint.

                         use_bias=st.booleans(),
           **hu.gcs)
    @settings(max_examples=2, deadline=None)
    def test_group_convolution(
            self, stride, pad, kernel, size, group,
            input_channels_per_group, output_channels_per_group, batch_size,
            order, engine, use_bias, gc, dc):
        assume(size >= kernel)


            

Reported by Pylint.

                              if param not in self.state:
                    self.state[param] = {}
                    state = self.state[param]
                    state['step'] = torch.tensor(0.0)
                    state['square_avg'] = torch.zeros_like(param, memory_format=torch.preserve_format)
                    if momentum > 0:
                        state['momentum_buffer'] = torch.zeros_like(param, memory_format=torch.preserve_format)
                    if self.centered:
                        state['grad_avg'] = torch.zeros_like(param, memory_format=torch.preserve_format)

            

Reported by Pylint.

                                  self.state[param] = {}
                    state = self.state[param]
                    state['step'] = torch.tensor(0.0)
                    state['square_avg'] = torch.zeros_like(param, memory_format=torch.preserve_format)
                    if momentum > 0:
                        state['momentum_buffer'] = torch.zeros_like(param, memory_format=torch.preserve_format)
                    if self.centered:
                        state['grad_avg'] = torch.zeros_like(param, memory_format=torch.preserve_format)


            

Reported by Pylint.

                                  self.state[param] = {}
                    state = self.state[param]
                    state['step'] = torch.tensor(0.0)
                    state['square_avg'] = torch.zeros_like(param, memory_format=torch.preserve_format)
                    if momentum > 0:
                        state['momentum_buffer'] = torch.zeros_like(param, memory_format=torch.preserve_format)
                    if self.centered:
                        state['grad_avg'] = torch.zeros_like(param, memory_format=torch.preserve_format)


            

Reported by Pylint.

                                  state['step'] = torch.tensor(0.0)
                    state['square_avg'] = torch.zeros_like(param, memory_format=torch.preserve_format)
                    if momentum > 0:
                        state['momentum_buffer'] = torch.zeros_like(param, memory_format=torch.preserve_format)
                    if self.centered:
                        state['grad_avg'] = torch.zeros_like(param, memory_format=torch.preserve_format)

                state = self.state[param]
                square_avgs.append(state['square_avg'])

            

Reported by Pylint.

                                  state['step'] = torch.tensor(0.0)
                    state['square_avg'] = torch.zeros_like(param, memory_format=torch.preserve_format)
                    if momentum > 0:
                        state['momentum_buffer'] = torch.zeros_like(param, memory_format=torch.preserve_format)
                    if self.centered:
                        state['grad_avg'] = torch.zeros_like(param, memory_format=torch.preserve_format)

                state = self.state[param]
                square_avgs.append(state['square_avg'])

            

Reported by Pylint.

                                  if momentum > 0:
                        state['momentum_buffer'] = torch.zeros_like(param, memory_format=torch.preserve_format)
                    if self.centered:
                        state['grad_avg'] = torch.zeros_like(param, memory_format=torch.preserve_format)

                state = self.state[param]
                square_avgs.append(state['square_avg'])
                if momentum > 0:
                    momentum_buffer_list.append(state['momentum_buffer'])

            

Reported by Pylint.

                                  if momentum > 0:
                        state['momentum_buffer'] = torch.zeros_like(param, memory_format=torch.preserve_format)
                    if self.centered:
                        state['grad_avg'] = torch.zeros_like(param, memory_format=torch.preserve_format)

                state = self.state[param]
                square_avgs.append(state['square_avg'])
                if momentum > 0:
                    momentum_buffer_list.append(state['momentum_buffer'])

            

Reported by Pylint.

              from typing import List, Dict, Optional
import torch
import torch.optim._functional as F

from torch import Tensor

# Define a TorchScript compatible Functional RMSprop Optimizer
# where we use these optimizer in a functional way.
# Instead of using the `param.grad` when updating parameters,

            

Reported by Pylint.

              # NOTE: This should be only used by distributed optimizer internals
# and not meant to expose to the user.
@torch.jit.script
class _FunctionalRMSprop(object):
    def __init__(
        self,
        params: List[Tensor],
        lr: float = 1e-2,
        alpha: float = 0.99,

            

Reported by Pylint.

              # NOTE: This should be only used by distributed optimizer internals
# and not meant to expose to the user.
@torch.jit.script
class _FunctionalRMSprop(object):
    def __init__(
        self,
        params: List[Tensor],
        lr: float = 1e-2,
        alpha: float = 0.99,

            

Reported by Pylint.

              import torch
from torch import Tensor

from .phony import get_phony

__all__: List[str] = []


def fork(input: Tensor) -> Tuple[Tensor, Tensor]:

            

Reported by Pylint.

              
def fork(input: Tensor) -> Tuple[Tensor, Tensor]:
    """Branches out from an autograd lane of the given tensor."""
    if torch.is_grad_enabled() and input.requires_grad:
        input, phony = Fork.apply(input)
    else:
        phony = get_phony(input.device, requires_grad=False)

    return input, phony

            

Reported by Pylint.

                  if torch.is_grad_enabled() and input.requires_grad:
        input, phony = Fork.apply(input)
    else:
        phony = get_phony(input.device, requires_grad=False)

    return input, phony


class Fork(torch.autograd.Function):

            

Reported by Pylint.

              
def join(input: Tensor, phony: Tensor) -> Tensor:
    """Merges two autograd lanes."""
    if torch.is_grad_enabled() and (input.requires_grad or phony.requires_grad):
        input = Join.apply(input, phony)

    return input



            

Reported by Pylint.

              __all__: List[str] = []


def fork(input: Tensor) -> Tuple[Tensor, Tensor]:
    """Branches out from an autograd lane of the given tensor."""
    if torch.is_grad_enabled() and input.requires_grad:
        input, phony = Fork.apply(input)
    else:
        phony = get_phony(input.device, requires_grad=False)

            

Reported by Pylint.

              
class Fork(torch.autograd.Function):
    @staticmethod
    def forward(ctx: "Fork", input: Tensor) -> Tuple[Tensor, Tensor]:  # type: ignore[override]
        phony = get_phony(input.device, requires_grad=False)
        return input.detach(), phony.detach()

    @staticmethod
    def backward(ctx: "Fork", grad_input: Tensor, grad_grad: Tensor) -> Tensor:  # type: ignore[override]

            

Reported by Pylint.

              
class Fork(torch.autograd.Function):
    @staticmethod
    def forward(ctx: "Fork", input: Tensor) -> Tuple[Tensor, Tensor]:  # type: ignore[override]
        phony = get_phony(input.device, requires_grad=False)
        return input.detach(), phony.detach()

    @staticmethod
    def backward(ctx: "Fork", grad_input: Tensor, grad_grad: Tensor) -> Tensor:  # type: ignore[override]

            

Reported by Pylint.

                      return input.detach(), phony.detach()

    @staticmethod
    def backward(ctx: "Fork", grad_input: Tensor, grad_grad: Tensor) -> Tensor:  # type: ignore[override]
        return grad_input


def join(input: Tensor, phony: Tensor) -> Tensor:
    """Merges two autograd lanes."""

            

Reported by Pylint.

                      return input.detach(), phony.detach()

    @staticmethod
    def backward(ctx: "Fork", grad_input: Tensor, grad_grad: Tensor) -> Tensor:  # type: ignore[override]
        return grad_input


def join(input: Tensor, phony: Tensor) -> Tensor:
    """Merges two autograd lanes."""

            

Reported by Pylint.

                      return grad_input


def join(input: Tensor, phony: Tensor) -> Tensor:
    """Merges two autograd lanes."""
    if torch.is_grad_enabled() and (input.requires_grad or phony.requires_grad):
        input = Join.apply(input, phony)

    return input

            

Reported by Pylint.

              import torch
import torch.distributed as dist

from . import default_hooks as default


class PostLocalSGDState(object):
    r"""
    Stores the state for all-reducing gradients globally using ``process_group`` until step ``start_localSGD_iter``,

            

Reported by Pylint.

                      start_localSGD_iter,
    ):
        logging.info(
            "Local SGD will be started after {} iterations".format(start_localSGD_iter)
        )

        # The group used for all-reducing gradients globally.
        self.process_group = process_group
        # The group used for all-reducing gradients locally.

            

Reported by Pylint.

              
        if self.iter == self.start_localSGD_iter:
            logging.info(
                "Start to apply local SGD after {} iterations.".format(self.iter)
            )


def post_localSGD_hook(
    state: PostLocalSGDState, bucket: dist.GradBucket

            

Reported by Pylint.

                  global_group_to_use = (
        state.process_group if state.process_group is not None else dist.group.WORLD
    )
    world_size = global_group_to_use.size()

    # The input tensor is a flattened 1D tensor.
    input_tensor = bucket.buffer()

    # Run allreduce using `global_group_to_use` in the first `start_localSGD_iter` iterations.

            

Reported by Pylint.

                  # Run allreduce using `global_group_to_use` in the first `start_localSGD_iter` iterations.
    if state.iter < state.start_localSGD_iter:
        state.maybe_increase_iter(bucket)
        return default._allreduce_fut(global_group_to_use, input_tensor)

    # Run allreduce using `subgroup` after the first `start_localSGD_iter` iterations.
    # From this moment, model averaging should run after the optimizer step,
    # to globally allreduce all the parameters.
    if state.subgroup is None:

            

Reported by Pylint.

                  # to globally allreduce all the parameters.
    if state.subgroup is None:
        state.subgroup, _ = dist.new_subgroups()
    return default._allreduce_fut(state.subgroup, input_tensor)

            

Reported by Pylint.

              import logging

import torch
import torch.distributed as dist

from . import default_hooks as default


class PostLocalSGDState(object):

            

Reported by Pylint.

              import logging

import torch
import torch.distributed as dist

from . import default_hooks as default


class PostLocalSGDState(object):

            

Reported by Pylint.

              from . import default_hooks as default


class PostLocalSGDState(object):
    r"""
    Stores the state for all-reducing gradients globally using ``process_group`` until step ``start_localSGD_iter``,
    and all-reducing gradients locally using ``subgroup`` afterwards.

    If ``process_group`` is ``None``, the global process group will be used.

            

Reported by Pylint.

              from . import default_hooks as default


class PostLocalSGDState(object):
    r"""
    Stores the state for all-reducing gradients globally using ``process_group`` until step ``start_localSGD_iter``,
    and all-reducing gradients locally using ``subgroup`` afterwards.

    If ``process_group`` is ``None``, the global process group will be used.

            

Reported by Pylint.

              from typing import Optional, TextIO, Union

try:
    import etcd  # type: ignore[import]
except ModuleNotFoundError:
    pass


log = logging.getLogger(__name__)

            

Reported by Pylint.

                  )

    for addr in addrs:
        family, type, proto, _, _ = addr
        try:
            s = socket.socket(family, type, proto)
            s.bind(("localhost", 0))
            s.listen(0)
            return s

            

Reported by Pylint.

                  raise RuntimeError("Failed to create a socket")


def stop_etcd(subprocess, data_dir: Optional[str] = None):
    if subprocess and subprocess.poll() is None:
        log.info("stopping etcd server")
        subprocess.terminate()
        subprocess.wait()


            

Reported by Pylint.

                      subprocess.wait()

    if data_dir:
        log.info(f"deleting etcd data dir: {data_dir}")
        shutil.rmtree(data_dir, ignore_errors=True)


class EtcdServer:
    """

            

Reported by Pylint.

                              data_dir = os.path.join(self._base_data_dir, str(curr_retries))
                os.makedirs(data_dir, exist_ok=True)
                return self._start(data_dir, timeout, stderr)
            except Exception as e:
                curr_retries += 1
                stop_etcd(self._etcd_proc)
                log.warning(
                    f"Failed to start etcd server, got error: {str(e)}, retrying"
                )

            

Reported by Pylint.

                          except Exception as e:
                curr_retries += 1
                stop_etcd(self._etcd_proc)
                log.warning(
                    f"Failed to start etcd server, got error: {str(e)}, retrying"
                )
                if curr_retries >= num_retries:
                    shutil.rmtree(self._base_data_dir, ignore_errors=True)
                    raise

            

Reported by Pylint.

                          )
        )

        log.info(f"Starting etcd server: [{etcd_cmd}]")

        sock.close()
        sock_peer.close()
        self._etcd_proc = subprocess.Popen(etcd_cmd, close_fds=True, stderr=stderr)
        self._wait_for_ready(timeout)

            

Reported by Pylint.

                                  f"Etcd server process exited with the code: {exitcode}"
                )
            try:
                log.info(f"etcd server ready. version: {client.version}")
                return
            except Exception:
                time.sleep(1)
        raise TimeoutError("Timed out waiting for etcd server to be ready!")


            

Reported by Pylint.

                          try:
                log.info(f"etcd server ready. version: {client.version}")
                return
            except Exception:
                time.sleep(1)
        raise TimeoutError("Timed out waiting for etcd server to be ready!")

    def stop(self) -> None:
        """

            

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 atexit
import logging

            

Reported by Pylint.

              import operator
import torch
import tensorrt as trt
from torch.fx.experimental.fx2trt.fx2trt import tensorrt_converter

from .helper_functions import get_dyn_range, mark_as_int8_layer

@tensorrt_converter(operator.add)
@tensorrt_converter(torch.add)

            

Reported by Pylint.

              import tensorrt as trt
from torch.fx.experimental.fx2trt.fx2trt import tensorrt_converter

from .helper_functions import get_dyn_range, mark_as_int8_layer

@tensorrt_converter(operator.add)
@tensorrt_converter(torch.add)
def add(network, target, args, kwargs, layer_name):
    # operator.add

            

Reported by Pylint.

              from .helper_functions import get_dyn_range, mark_as_int8_layer

@tensorrt_converter(operator.add)
@tensorrt_converter(torch.add)
def add(network, target, args, kwargs, layer_name):
    # operator.add
    if len(kwargs) == 0:
        lhs_val, rhs_val = args
    else:

            

Reported by Pylint.

              
    layer = network.add_elementwise(lhs_val, rhs_val, trt.ElementWiseOperation.SUM)
    layer.name = layer_name
    dyn_range = get_dyn_range(kwargs["scale"], kwargs["zero_point"], torch.quint8)
    mark_as_int8_layer(layer, dyn_range)

    return layer.get_output(0)



            

Reported by Pylint.

              
    layer = network.add_elementwise(lhs_val, rhs_val, trt.ElementWiseOperation.SUM)
    layer.name = f"{layer_name}_add"
    dyn_range = get_dyn_range(kwargs["scale"], kwargs["zero_point"], torch.quint8)
    mark_as_int8_layer(layer, dyn_range)

    layer = network.add_activation(
        input=layer.get_output(0), type=trt.ActivationType.RELU)
    layer.name = f"{layer_name}_relu"

            

Reported by Pylint.

              
@tensorrt_converter(operator.add)
@tensorrt_converter(torch.add)
def add(network, target, args, kwargs, layer_name):
    # operator.add
    if len(kwargs) == 0:
        lhs_val, rhs_val = args
    else:
        # torch.add

            

Reported by Pylint.

              

@tensorrt_converter(torch.ops.quantized.add)
def quantized_add(network, target, args, kwargs, layer_name):
    lhs_val, rhs_val = kwargs["qa"], kwargs["qb"]

    if not all(isinstance(i, trt.tensorrt.ITensor) for i in [lhs_val, rhs_val]):
        raise RuntimeError('Quantized add received an input that is not part of the TensorRT region!')


            

Reported by Pylint.

              

@tensorrt_converter(torch.ops.quantized.add)
def quantized_add(network, target, args, kwargs, layer_name):
    lhs_val, rhs_val = kwargs["qa"], kwargs["qb"]

    if not all(isinstance(i, trt.tensorrt.ITensor) for i in [lhs_val, rhs_val]):
        raise RuntimeError('Quantized add received an input that is not part of the TensorRT region!')


            

Reported by Pylint.

              

@tensorrt_converter(torch.ops.quantized.add_relu)
def quantized_add_relu(network, submod, args, kwargs, layer_name):
    lhs_val, rhs_val = kwargs["qa"], kwargs["qb"]

    if not all(isinstance(i, trt.tensorrt.ITensor) for i in [lhs_val, rhs_val]):
        raise RuntimeError('Quantized add_relu received an input that is not part of the TensorRT region!')


            

Reported by Pylint.

              

@tensorrt_converter(torch.ops.quantized.add_relu)
def quantized_add_relu(network, submod, args, kwargs, layer_name):
    lhs_val, rhs_val = kwargs["qa"], kwargs["qb"]

    if not all(isinstance(i, trt.tensorrt.ITensor) for i in [lhs_val, rhs_val]):
        raise RuntimeError('Quantized add_relu received an input that is not part of the TensorRT region!')


            

Reported by Pylint.

              
    def __init__(self, rate, validate_args=None):
        self.rate, = broadcast_all(rate)
        batch_shape = torch.Size() if isinstance(rate, Number) else self.rate.size()
        super(Exponential, self).__init__(batch_shape, validate_args=validate_args)

    def expand(self, batch_shape, _instance=None):
        new = self._get_checked_instance(Exponential, _instance)
        batch_shape = torch.Size(batch_shape)

            

Reported by Pylint.

              
    def expand(self, batch_shape, _instance=None):
        new = self._get_checked_instance(Exponential, _instance)
        batch_shape = torch.Size(batch_shape)
        new.rate = self.rate.expand(batch_shape)
        super(Exponential, new).__init__(batch_shape, validate_args=False)
        new._validate_args = self._validate_args
        return new


            

Reported by Pylint.

                      new._validate_args = self._validate_args
        return new

    def rsample(self, sample_shape=torch.Size()):
        shape = self._extended_shape(sample_shape)
        if torch._C._get_tracing_state():
            # [JIT WORKAROUND] lack of support for ._exponential()
            u = torch.rand(shape, dtype=self.rate.dtype, device=self.rate.device)
            return -(-u).log1p() / self.rate

            

Reported by Pylint.

                      shape = self._extended_shape(sample_shape)
        if torch._C._get_tracing_state():
            # [JIT WORKAROUND] lack of support for ._exponential()
            u = torch.rand(shape, dtype=self.rate.dtype, device=self.rate.device)
            return -(-u).log1p() / self.rate
        return self.rate.new(shape).exponential_() / self.rate

    def log_prob(self, value):
        if self._validate_args:

            

Reported by Pylint.

                  def cdf(self, value):
        if self._validate_args:
            self._validate_sample(value)
        return 1 - torch.exp(-self.rate * value)

    def icdf(self, value):
        return -torch.log(1 - value) / self.rate

    def entropy(self):

            

Reported by Pylint.

                      return 1 - torch.exp(-self.rate * value)

    def icdf(self, value):
        return -torch.log(1 - value) / self.rate

    def entropy(self):
        return 1.0 - torch.log(self.rate)

    @property

            

Reported by Pylint.

                      return -torch.log(1 - value) / self.rate

    def entropy(self):
        return 1.0 - torch.log(self.rate)

    @property
    def _natural_params(self):
        return (-self.rate, )


            

Reported by Pylint.

                      return (-self.rate, )

    def _log_normalizer(self, x):
        return -torch.log(-x)

            

Reported by Pylint.

              from torch.distributions.utils import broadcast_all


class Exponential(ExponentialFamily):
    r"""
    Creates a Exponential distribution parameterized by :attr:`rate`.

    Example::


            

Reported by Pylint.

                      batch_shape = torch.Size(batch_shape)
        new.rate = self.rate.expand(batch_shape)
        super(Exponential, new).__init__(batch_shape, validate_args=False)
        new._validate_args = self._validate_args
        return new

    def rsample(self, sample_shape=torch.Size()):
        shape = self._extended_shape(sample_shape)
        if torch._C._get_tracing_state():

            

Reported by Pylint.

              from tools.linter import trailing_newlines
import unittest
import tempfile


def correct_trailing_newlines(file_contents: str) -> bool:
    with tempfile.NamedTemporaryFile(mode='w', delete=False) as tmp:
        filename = tmp.name
        tmp.write(file_contents)

            

Reported by Pylint.

              from tools.linter import trailing_newlines
import unittest
import tempfile


def correct_trailing_newlines(file_contents: str) -> bool:
    with tempfile.NamedTemporaryFile(mode='w', delete=False) as tmp:
        filename = tmp.name
        tmp.write(file_contents)

            

Reported by Pylint.

              from tools.linter import trailing_newlines
import unittest
import tempfile


def correct_trailing_newlines(file_contents: str) -> bool:
    with tempfile.NamedTemporaryFile(mode='w', delete=False) as tmp:
        filename = tmp.name
        tmp.write(file_contents)

            

Reported by Pylint.

              from tools.linter import trailing_newlines
import unittest
import tempfile


def correct_trailing_newlines(file_contents: str) -> bool:
    with tempfile.NamedTemporaryFile(mode='w', delete=False) as tmp:
        filename = tmp.name
        tmp.write(file_contents)

            

Reported by Pylint.

              import tempfile


def correct_trailing_newlines(file_contents: str) -> bool:
    with tempfile.NamedTemporaryFile(mode='w', delete=False) as tmp:
        filename = tmp.name
        tmp.write(file_contents)
    return trailing_newlines.correct_trailing_newlines(filename)


            

Reported by Pylint.

                  return trailing_newlines.correct_trailing_newlines(filename)


class TestTrailingNewlines(unittest.TestCase):
    def test_empty(self) -> None:
        self.assertTrue(correct_trailing_newlines(''))

    def test_single_byte(self) -> None:
        self.assertFalse(correct_trailing_newlines('a'))

            

Reported by Pylint.

              

class TestTrailingNewlines(unittest.TestCase):
    def test_empty(self) -> None:
        self.assertTrue(correct_trailing_newlines(''))

    def test_single_byte(self) -> None:
        self.assertFalse(correct_trailing_newlines('a'))


            

Reported by Pylint.

                  def test_empty(self) -> None:
        self.assertTrue(correct_trailing_newlines(''))

    def test_single_byte(self) -> None:
        self.assertFalse(correct_trailing_newlines('a'))

    def test_single_newline(self) -> None:
        self.assertFalse(correct_trailing_newlines('\n'))


            

Reported by Pylint.

                  def test_single_byte(self) -> None:
        self.assertFalse(correct_trailing_newlines('a'))

    def test_single_newline(self) -> None:
        self.assertFalse(correct_trailing_newlines('\n'))

    def test_two_newlines(self) -> None:
        self.assertFalse(correct_trailing_newlines('\n\n'))


            

Reported by Pylint.

                  def test_single_newline(self) -> None:
        self.assertFalse(correct_trailing_newlines('\n'))

    def test_two_newlines(self) -> None:
        self.assertFalse(correct_trailing_newlines('\n\n'))

    def test_three_newlines(self) -> None:
        self.assertFalse(correct_trailing_newlines('\n\n\n'))


            

Reported by Pylint.

              
class ParseError(Exception):
    """Whenever the simple parser is unable to parse the report, this exception will be raised"""
    pass


class Report:
    """A report is a container of errors, and a summary on how many errors are found"""


            

Reported by Pylint.

              # this file contains a simple parser that parses report
# from cuda-memcheck

class ParseError(Exception):
    """Whenever the simple parser is unable to parse the report, this exception will be raised"""
    pass


class Report:

            

Reported by Pylint.

                  pass


class Report:
    """A report is a container of errors, and a summary on how many errors are found"""

    def __init__(self, text, errors):
        # text is something like
        # ERROR SUMMARY: 1 error

            

Reported by Pylint.

                              raise ParseError("Number of errors does not match")


class Error:
    """Each error is a section in the output of cuda-memcheck.
    Each error in the report has an error message and a backtrace. It looks like:

    ========= Program hit cudaErrorInvalidValue (error 1) due to "invalid argument" on CUDA API call to cudaGetLastError.
    =========     Saved host backtrace up to driver entry point at error

            

Reported by Pylint.

                  """Each error is a section in the output of cuda-memcheck.
    Each error in the report has an error message and a backtrace. It looks like:

    ========= Program hit cudaErrorInvalidValue (error 1) due to "invalid argument" on CUDA API call to cudaGetLastError.
    =========     Saved host backtrace up to driver entry point at error
    =========     Host Frame:/usr/lib/x86_64-linux-gnu/libcuda.so.1 [0x38c7b3]
    =========     Host Frame:/usr/local/cuda/lib64/libcudart.so.10.1 (cudaGetLastError + 0x163) [0x4c493]
    =========     Host Frame:/home/xgao/anaconda3/lib/python3.7/site-packages/torch/lib/libtorch.so [0x5b77a05]
    =========     Host Frame:/home/xgao/anaconda3/lib/python3.7/site-packages/torch/lib/libtorch.so [0x39d6d1d]

            

Reported by Pylint.

                  ========= Program hit cudaErrorInvalidValue (error 1) due to "invalid argument" on CUDA API call to cudaGetLastError.
    =========     Saved host backtrace up to driver entry point at error
    =========     Host Frame:/usr/lib/x86_64-linux-gnu/libcuda.so.1 [0x38c7b3]
    =========     Host Frame:/usr/local/cuda/lib64/libcudart.so.10.1 (cudaGetLastError + 0x163) [0x4c493]
    =========     Host Frame:/home/xgao/anaconda3/lib/python3.7/site-packages/torch/lib/libtorch.so [0x5b77a05]
    =========     Host Frame:/home/xgao/anaconda3/lib/python3.7/site-packages/torch/lib/libtorch.so [0x39d6d1d]
    =========     .....
    """


            

Reported by Pylint.

                  =========     Saved host backtrace up to driver entry point at error
    =========     Host Frame:/usr/lib/x86_64-linux-gnu/libcuda.so.1 [0x38c7b3]
    =========     Host Frame:/usr/local/cuda/lib64/libcudart.so.10.1 (cudaGetLastError + 0x163) [0x4c493]
    =========     Host Frame:/home/xgao/anaconda3/lib/python3.7/site-packages/torch/lib/libtorch.so [0x5b77a05]
    =========     Host Frame:/home/xgao/anaconda3/lib/python3.7/site-packages/torch/lib/libtorch.so [0x39d6d1d]
    =========     .....
    """

    def __init__(self, lines):

            

Reported by Pylint.

                  =========     Host Frame:/usr/lib/x86_64-linux-gnu/libcuda.so.1 [0x38c7b3]
    =========     Host Frame:/usr/local/cuda/lib64/libcudart.so.10.1 (cudaGetLastError + 0x163) [0x4c493]
    =========     Host Frame:/home/xgao/anaconda3/lib/python3.7/site-packages/torch/lib/libtorch.so [0x5b77a05]
    =========     Host Frame:/home/xgao/anaconda3/lib/python3.7/site-packages/torch/lib/libtorch.so [0x39d6d1d]
    =========     .....
    """

    def __init__(self, lines):
        self.message = lines[0]

            

Reported by Pylint.

                  A report contains multiple errors and a summary on how many errors are detected. It looks like:

    ========= CUDA-MEMCHECK
    ========= Program hit cudaErrorInvalidValue (error 1) due to "invalid argument" on CUDA API call to cudaPointerGetAttributes.
    =========     Saved host backtrace up to driver entry point at error
    =========     Host Frame:/usr/lib/x86_64-linux-gnu/libcuda.so.1 [0x38c7b3]
    =========     Host Frame:/usr/local/cuda/lib64/libcudart.so.10.1 (cudaPointerGetAttributes + 0x1a9) [0x428b9]
    =========     Host Frame:/home/xgao/anaconda3/lib/python3.7/site-packages/torch/lib/libtorch.so [0x5b778a9]
    =========     .....

            

Reported by Pylint.

                  ========= Program hit cudaErrorInvalidValue (error 1) due to "invalid argument" on CUDA API call to cudaPointerGetAttributes.
    =========     Saved host backtrace up to driver entry point at error
    =========     Host Frame:/usr/lib/x86_64-linux-gnu/libcuda.so.1 [0x38c7b3]
    =========     Host Frame:/usr/local/cuda/lib64/libcudart.so.10.1 (cudaPointerGetAttributes + 0x1a9) [0x428b9]
    =========     Host Frame:/home/xgao/anaconda3/lib/python3.7/site-packages/torch/lib/libtorch.so [0x5b778a9]
    =========     .....
    =========
    ========= Program hit cudaErrorInvalidValue (error 1) due to "invalid argument" on CUDA API call to cudaGetLastError.
    =========     Saved host backtrace up to driver entry point at error

            

Reported by Pylint.

              # Some standard imports
import numpy as np
from torch import nn
import torch.onnx
import torch.nn.init as init
from caffe2.python.model_helper import ModelHelper
from pytorch_helper import PyTorchModule
import unittest
from caffe2.python.core import workspace

            

Reported by Pylint.

              # Some standard imports
import numpy as np
from torch import nn
import torch.onnx
import torch.nn.init as init
from caffe2.python.model_helper import ModelHelper
from pytorch_helper import PyTorchModule
import unittest
from caffe2.python.core import workspace

            

Reported by Pylint.

              import numpy as np
from torch import nn
import torch.onnx
import torch.nn.init as init
from caffe2.python.model_helper import ModelHelper
from pytorch_helper import PyTorchModule
import unittest
from caffe2.python.core import workspace


            

Reported by Pylint.

              from torch import nn
import torch.onnx
import torch.nn.init as init
from caffe2.python.model_helper import ModelHelper
from pytorch_helper import PyTorchModule
import unittest
from caffe2.python.core import workspace

from test_pytorch_common import skipIfNoLapack

            

Reported by Pylint.

              from caffe2.python.model_helper import ModelHelper
from pytorch_helper import PyTorchModule
import unittest
from caffe2.python.core import workspace

from test_pytorch_common import skipIfNoLapack


class TestCaffe2Backend(unittest.TestCase):

            

Reported by Pylint.

              import unittest
from caffe2.python.core import workspace

from test_pytorch_common import skipIfNoLapack


class TestCaffe2Backend(unittest.TestCase):

    @skipIfNoLapack

            

Reported by Pylint.

              # Some standard imports
import numpy as np
from torch import nn
import torch.onnx
import torch.nn.init as init
from caffe2.python.model_helper import ModelHelper
from pytorch_helper import PyTorchModule
import unittest
from caffe2.python.core import workspace

            

Reported by Pylint.

              import torch.nn.init as init
from caffe2.python.model_helper import ModelHelper
from pytorch_helper import PyTorchModule
import unittest
from caffe2.python.core import workspace

from test_pytorch_common import skipIfNoLapack



            

Reported by Pylint.

              from caffe2.python.model_helper import ModelHelper
from pytorch_helper import PyTorchModule
import unittest
from caffe2.python.core import workspace

from test_pytorch_common import skipIfNoLapack


class TestCaffe2Backend(unittest.TestCase):

            

Reported by Pylint.

              from caffe2.python.model_helper import ModelHelper
from pytorch_helper import PyTorchModule
import unittest
from caffe2.python.core import workspace

from test_pytorch_common import skipIfNoLapack


class TestCaffe2Backend(unittest.TestCase):

            

Reported by Pylint.