Subclasses of NamedTuple

[progval]

Hi,

I often use a subclass to a namedtuple to add optional arguments (and/or methods) to a namedtuple.

For instance, this gives this kind of code:

     1	from typing import *
     2	
     3	_Foo = NamedTuple('_Foo', [
     4	    ('bar', str),
     5	    ('baz', str),
     6	    ])
     7	
     8	class Foo(_Foo):
     9	    def __new__(cls, bar, baz='z') -> 'Foo':
    10	        return _Foo.__new__(cls, bar, baz)
    11	
    12	def f() -> None:
    13	    print(repr(Foo('r')))
    14	
    15	f() # prints Foo(bar='r', baz='z')

which I think is completely valid Python.

However, Mypy raises the following errors:

foo.py:10: error: Too many arguments for "__new__" of "object"
foo.py:10: error: Argument 1 to "__new__" of "object" has incompatible type Type[Foo]; expected Type[object]
foo.py:13: error: Too few arguments for "Foo"

Is there something I am doing wrong?

Thanks!

[miedzinski]

It seems to work if you use super() instead of referencing _Foo directly. I don't believe it has anything to do with namedtuples.

from typing import NamedTuple

_Foo = NamedTuple('_Foo', [
    ('bar', str),
    ('baz', str),
])

class Foo(_Foo):
    def __new__(cls, bar, baz='z') -> 'Foo':
        return super().__new__(cls, bar, baz)

OTOH I'm not sure whether mypy properly typechecks namedtuples unless they subclass directly from typing.NamedTuple. See

mypy/mypy/semanal.py

Lines 890 to 906 in 8709da5

	def analyze_namedtuple_classdef(self, defn: ClassDef) -> Optional[TypeInfo]:
	# special case for NamedTuple
	for base_expr in defn.base_type_exprs:
	if isinstance(base_expr, RefExpr):
	base_expr.accept(self)
	if base_expr.fullname == 'typing.NamedTuple':
	node = self.lookup(defn.name, defn)
	if node is not None:
	node.kind = GDEF # TODO in process_namedtuple_definition also applies here
	items, types, default_items = self.check_namedtuple_classdef(defn)
	info = self.build_namedtuple_typeinfo(
	defn.name, items, types, default_items)
	node.node = info
	defn.info = info
	defn.analyzed = NamedTupleExpr(info)
	return info
	return None

.

[progval]

I didn't know I could use super() in __new__, thanks.

I replaced _Foo with super(), and now I am only getting this:

foo.py:13: error: Too few arguments for "Foo"

[ilevkivskyi]

@progval
By the way, switching to Python 3.6 will give you typing.NamedTuple that supports optional arguments, methods, docstrings, and nice static typing (supported by mypy):

from typing import NamedTuple

class Link(NamedTuple):
    """Represent a link between two nodes."""
    start: int
    end: int
    label: str = '<no name>'
    def weight(self) -> float:
        return abs(self.end - self.start)/2

[Daenyth]

Since you're on python3, you might want to use the syntax instead, like this:

class Foo(NamedTuple):
    bar: str
    baz: str = 'z'

I use this in my project and mypy deals with it just fine. It's also much more readable.

[ilevkivskyi]

Concerning __new__ we already have #1279 so that this one can be closed