What is typedtuple?

To put it plainly, it can be described declaratively in the format of voluptuous / named tuple that validates at the time of generation. It is intended for so-called case class use.

A little more detail

For example, when handling various row items in a DB, you can use a raw dict, but I want to type it so that the intention can be conveyed by subscript access or the dull code itself, but it is too match to define the class for that. Don't you think? I have

Also, you can use toolz or fn.py to write in python like FP, Don't you think you want an immutable object? I have

Both of these are problems that can be solved simply by using namedtuple, but on top of that, it is necessary to check what the attribute type is now, which becomes troublesome when writing a large amount of application code. There was, for example, that I wanted to automatically convert ISO-8601 strings to datetime.

In response to this situation, typedtuple aims to provide an implementation in which type checking and conversion are automatically performed when a namedtuple is created simply by declaratively describing the type structure.

How to use

I wrote a lot in here, but use typedtuple.TypedTuple in the same way as namedtuple or use typedtuple.schema decorator (property and method for TypedTuple) If you want to add), define the type by specifying voluptuous.Schema. When creating an instance, value verification and automatic conversion are performed using the specified Schema. For verification / conversion by voluptuous, refer to the document and code there.

from typedtuple import TypedTuple
from voluptuous import Coerce

Vector = TypedTuple('Vector', {'x': Coerce(float), 'y': Coerce(float)})

v0 = Vector(x=10, y='20.0')

# voluptuous.Coerce will automatically convert anything that can be converted to float
print v0  # Vector(x=10.0, y=20.0)

v1 = Vector(x='x', y=20.0)  # raises exception

# TypedTuple=Since it is namedtuple and immutable, updating the attribute is namedtuple._Will use replace to generate another value
v2 = v0._replace(y=30.0)

important point

Since the structure is specified by dict, which does not guarantee the order of elements, it is not possible to specify the order of attributes as it is even though it is actually tuple. It shouldn't be a problem for basic usage, but if you want to specify the order strictly, you can use collections.OrderedDict.

from collections import OrderedDict
from typedtuple import TypedTuple
from voluptuous import Coerce

Vector = TypedTuple('Vector', OrderedDict((('x', Coerce(float)), ('y', Coerce(float))))
print Vector._fields  #you have to('x', 'y', 'z')become(OrderedDictを使わない場合、順序は不定become)

Another caveat is that it's probably quite heavy to generate. Maybe it can't be helped, so take a benchmark.

Other examples

from voluptuous import All, Range, Length, Optional
from typedtuple import schema

@schema({
    'id': All(int, Range(min=0)),                #id is always a positive integer
    'password': All(str, Length(min=8)),  #password is a string of 8 or more characters
    'first_name': str,
    'last_name': str,
    Optional('nickname'): str,            #Can be omitted when generating if set to Optional
})
class User(object):
    # typedtuple(Or rather named tuple)Cannot add attributes, but can add properties and methods
    @property
    def full_name(self):
        return '{} {}'.format(self.first_name, self.nick_name)

# raises exception
alice = User(id=-1, password='xxxxxxxx', first_name='Alice', last_name='Kakehashi', nick_name='kkhs')

# raises exception
bob = User(id=1, password='short', first_name='Bob', last_name='Kakehashi', nick_name='kkhs')

# nick_name is optional
carol = User(id=2, password='xxxxxxxx', first_name='Carol', last_name='Kakehashi')

the end

I will write about voluptuous soon.