create custom namedtuple type with extra features

Question

I'd like to create my own type of build-in namedtuple that has some extra features. Let's say we create a class:

from collections import namedtuple
MyClass = namedtuple('MyClass', 'field1 field2')

It`s immutable, readable and simple. Now I can create instances of MyClass:

myobj = MyClass(field1 = 1, field2 = 3.0)
print(myobj.field1, myobj.field2)

My extra requirement is when instance is created I'd like to check if field1 is int type and field2 is float. For example if user try to create MyClass instance:

obj = MyClass(field1 = 1, field2 = 3.0) # instantiates ok
obj1 = MyClass(field1 = 'sometext', field2 = 3.0) # raises TypeError

I tried to make a customized namedtuple that can validate datatypes (MyClass should be immutable) something like.:

MyClass = modifiednamedtuple('MyClass', 'field1 field2', (int, float) )

but got stuck :(. namedtuple is function (cannot be a baseclass for modifiednamedtuple), my experiments with metaclasses failed.

Any tips or suggestions?

ok, I came up with a solution that might be not "clean" or pythonic. It works except that my objects are not immutable. How to make them immutable? Any suggestions how to make it more clean and redable?

Here is my code.:

def typespecificnamedtuple(name, *attr_definitions):

    def init(self, *args, **kwargs):
        valid_types = dict(attr_definitions) # tuples2dict
        for attr_name, value in kwargs.items():
            valid_type = valid_types[attr_name]
            if not isinstance(value, valid_type):
                raise TypeError('Cannot instantiate class '+ self.__name__+
                    '. Inproper datatype for '+ attr_name + '=' + str(value)+ 
                        ', expected '+str(valid_type) )
            setattr(self, attr_name, value)


    class_dict = {'__init__' : init, '__name__' : name}
    for attr_def in attr_definitions:
        class_dict[attr_def[0]] = attr_def[1] # attr_def is ('name', <type int>)

    customType = type(name, (object, ), class_dict )
    return customType

if __name__ == '__main__':
    MyClass = typespecificnamedtuple('MyClass', ('value', int), ('value2', float)  )
    mc = MyClass(value = 1, value2 = 3.0)
    mc.something = 1    # this assigment is possible :( how to make immutable?
    print(mc.__name__, mc.value, mc.value2, mc.something)
    mc1 = MyClass(value = 1, value2 = 'sometext')   # TypeError exception is raised

and console output.:

MyClass 1 3.0 1
Traceback (most recent call last):
  File "/home/pawel/workspace/prices/prices.py", line 89, in <module>
    mc1 = MyClass(value = 1, value2 = 'sometext')   # TypeError exception is raised
  File "/home/pawel/workspace/prices/prices.py", line 70, in init
    ', expected '+str(valid_type) )
TypeError: Cannot instantiate class MyClass. Inproper datatype for value2=sometext, expected <class 'float'>

Answer 1

namedtuple isn't a class, as you note; it's a function. But it's a function that returns a class. Thus, you can use the result of the namedtuple call as a parent class.

Since it is immutable, a namedtuple is initialized in __new__ rather in in __init__.

So something like this, perhaps:

MyTuple = namedtuple('MyTuple', 'field1 field2')

class MyClass(MyTuple):
    def __new__(cls, field1, field2):
        if not isinstance(field1, int):
            raise TypeError("field1 must be integer")
        # accept int or float for field2 and convert int to float
        if not isinstance(field1, (int, float)):
            raise TypeError("field2 must be float")
        return MyTuple.__new__(cls, field1, float(field2))

Answer 2

namedtuple() uses a string template to generate a class object.

You could use that same technique for your modified version; but do use the code already generated for you as a base class:

import sys
from collections import OrderedDict

_typechecking_class_template = """\
from collections import namedtuple as _namedtuple

class {typename}(_namedtuple({typename!r}, {field_names!r})):
    '{typename}({arg_list})'

    __slots__ = ()

    def __new__(_cls, {arg_list}):
        'Create new instance of {typename}({arg_list})'
        for name, type_ in _cls._field_types.items():
            value = locals()[name]
            if not isinstance(value, type_):
                raise TypeError("Incorrect type {{!r}} for {{}}, expected {{!r}}".format(
                    type(value).__name__, name, type_.__name__))
        return tuple.__new__(_cls, ({arg_list}))
"""

def typechecking_namedtuple(typename, field_names, field_types):
    if isinstance(field_names, str):
        field_names = field_names.replace(',', ' ').split()
    field_names = list(map(str, field_names))
    typename = str(typename)
    class_definition = _typechecking_class_template.format(
        typename = typename,
        field_names = tuple(field_names),
        arg_list = repr(tuple(field_names)).replace("'", "")[1:-1],
    )
    namespace = dict(__name__='typechecking_namedtuple_%s' % typename)
    exec(class_definition, namespace)
    result = namespace[typename]
    result._field_types = OrderedDict(zip(field_names, field_types))
    try:
        module = sys._getframe(1).f_globals.get('__name__', '__main__')
        result.__module__ = module
    except (AttributeError, ValueError):
        pass
    return result

This lets you produce new type-checking namedtuple classes:

>>> MyClass = typechecking_namedtuple('MyClass', 'field1 field2', (int, float))
>>> MyClass(42, 81.2)
MyClass(field1=42, field2=81.2)
>>> MyClass('fourtytwo', 81.2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 16, in __new__
TypeError: Incorrect type 'str' for field1, expected 'int'
>>> MyClass(42, None)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 16, in __new__
TypeError: Incorrect type 'NoneType' for field2, expected 'float'