unused-argument for required argument in __new__

[mkielg11]

I have a class where I overload the new() call.

The new __new__() call is required to have the same arguments as the __init__(), so after I make some checks, I call super().__new__(cls). In this, the input arguments are implicitly passed on to __init__().
However, I get the unused-argument pylint warning, as I do not use all the arguments within the __new__().

[PCManticore]

Can you provide an example?

[mkielg11]

class Example:
    """ Class doc string """
     __instances = dict()

    def __init__(self, name, x, y, z, test=None):
        self.name = name
        self.x = x
        self.y = y
        self.z = z
        if test is not None:
            self.test = test
        else:
            self. test = 'some default'

    def __new__(self, name, x, y, z, test=None):
        if name in self.__instances:
             assert self.__instances[name].x == x
             return self.__instances[name]
        else:
            instance = super(Example, cls).__new__(cls)
            cls.__instances[name] = instance
            return instance

[mkielg11]

I just wrote the example in the editor to remove application specific details, but the above should illustrate what I meant.

[pwwang]

Or to make it simpler:

class Example:
  def __new__(cls, *args, **kwargs):
    # no need to pass args, kwargs here, 
    # but pylint raises unused-argument
    return object.__new__(cls) 

  def __init__(self, *args, **kwargs):
    # args and kwargs were passed implicitly from __new__
    # do object initialization.

[mkielg11]

Yes, thank you @pwwang, I'll admit that is a better (and simpler) example, thank you :)

[hippo91]

Thanks for the reports and example @pwwang and @mkielg11!

[clavedeluna]

I wonder if we can just do a special case for __new__ here, since it appears that even Pycharm never marks args to it as unused (in gray) while for __init__ it does

[Tsjerfell]

Hi! I'm running into this issue now, and I'm just wondering if this is solved? Or do you have to disable the warning for all __new__ functions? (Not that you need to redefine __new__ too often)