Enthought traits.api TraitList() doesn't seem to support an item_validator

Question

In some applications, I've found that Enthought Traits.api is a helpful addition to support static variable types in python.

I'm trying to use the TraitList() item_validator keyword, but using the item_validator keyword threw an error... I tried this...

from traits.api import HasTraits, HasRequiredTraits, TraitList, TraitError
from traits.api import Regex, Enum

def garage_item_validator(item):
    """Validate item adjectives and reject pink or floral items"""
    try:
        if isinstance(item, Tool):
            if item.adjective!="pink" or item.adjective!="floral":
                return item
            else:
                raise ValueError()
    except ValueError():
        raise TraitError(f"Cannot put {item} in the Garage()")

class Tool(HasRequiredTraits):
    name = Regex(regex=r"[Ww]rench|[Ll]awnmower", required=True)
    adjective = Enum(*["brown", "rusty", "pink", "floral"], required=True)

    def __init__(self, name, adjective):
        self.name = name
        self.adjective = adjective

    def __repr__(self):
        return """<Tool: {}>""".format(self.name)

class Garage(HasTraits):
    things = TraitList(Tool, item_validator=garage_item_validator)  # <---- TraitList() doesn't work

    def __init__(self):
        self.things = list()

if __name__=="__main__":
    my_garage = Garage()
    my_garage.things.append(Tool("Lawnmower", "brown"))
    my_garage.things.append(Tool("wrench", "pink"))
    print(my_garage)

This throws: TypeError: __init__() got an unexpected keyword argument 'item_validator' although the TraitList docs clearly say item_validator is supported.

I also tried to use a traits.api List(), but it just silently ignores the item_validator keyword.

What should I use to validate the contents of a traits list?

Answer 1

TraitList isn't a Trait, but rather a subclass of list that performs validation and fires events. It is used internally by the List trait:

>>> from traits.api import HasStrictTraits, List, Int
>>> class Example(HasStrictTraits):
...     x = List(Int) 
... 
>>> example = Example()
>>> example.x
[]
>>> type(example.x)
<class 'traits.trait_list_object.TraitListObject'>
>>> type(example.x).mro()
[<class 'traits.trait_list_object.TraitListObject'>, <class 'traits.trait_list_object.TraitList'>, <class 'list'>, <class 'object'>]

and it gets its item_validator set by the List trait:

>>> example.x.item_validator
<bound method TraitListObject._item_validator of []>

So although there is no hook to change this validator, it does use the validator from the Trait used as the trait argument the List (Int in the above example, so the list will only hold integer items).

>>> example.x.append("five")
Traceback (most recent call last):
...
traits.trait_errors.TraitError: Each element of the 'x' trait of an Example instance must be an integer, but a value of 'five' <class 'str'> was specified.

So you can achieve your goal by writing a custom trait that validates the way that you want.

In your example you want the items to be instances of Tool with certain properties for the adjective, so an Instance trait is a good starting point:

from traits.api import BaseInstance, HasTraits, List

class GarageTool(BaseInstance):
    
    def __init__(self, **metadata):
        super().__init__(klass=Tool, allow_none=False, **metadata)
        
    def validate(self, object, name, value):
        # validate it is an instance of Tool
        value = super().validate(object, name, value)
        if value.adjective in {"pink", "floral"}:
            self.error(object, name, value)
        return value
    
    def info(self):
        # give better error messages
        return "a Tool which is neither pink nor floral"

class Garage(HasTraits):
    things = List(GarageTool())
    
if __name__ == "__main__":
    my_garage = Garage()
    my_garage.things.append(Tool("Lawnmower", "brown"))

    # now, pink correctly fails in garage_item_validator()
    my_garage.things.append(Tool("wrench", "pink")) # <-- pink fails

which gives an error as desired:

TraitError: Each element of the 'things' trait of a Garage instance must be a Tool which is neither pink nor floral, but a value of <__main__.Tool object at 0x7f899ad89830> <class '__main__.Tool'> was specified.

Answer 2

I made a mistake in my previous attempts...

This is wrong... Tool should be Tool()...

class Garage(HasTraits):
    things = TraitList(Tool, item_validator=garage_item_validator)

This is correct...

class Garage(HasTraits):
    things = TraitList(Tool(), item_validator=garage_item_validator)

Additionally, I found that I can manually assign self.things.item_validator after initializing the Garage()

This also runs correctly...

from traits.api import HasTraits, HasRequiredTraits, TraitList, TraitError
from traits.api import Regex, List, Enum, Either

def garage_item_validator(item):
    try:
        if isinstance(item, Tool):
            if item.adjective!="pink" and item.adjective!="floral":
                return item
            else:
                raise ValueError(item.adjective, item.name)
        else:
            raise ValueError(item.adjective, item.name)
    except Exception:
        raise ValueError(item.adjective, item.name)

class Tool(HasRequiredTraits):
    name = Regex(regex=r"[Ww]rench|[Ll]awnmower", required=True)
    adjective = Enum(*["brown", "rusty", "pink", "floral"])

    def __init__(self, name=None, adjective=None):
        self.name = name
        self.adjective = adjective

    def __repr__(self):
        return """<Tool: {}>""".format(self.name)

class Garage(HasTraits):
    things = TraitList(Tool())

    def __init__(self):
        self.things = list()
        self.things.item_validator = garage_item_validator
    #   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    #   Manually assign item_validator attr **after initializing self.things**

if __name__=="__main__":
    my_garage = Garage()
    my_garage.things.append(Tool("Lawnmower", "brown"))

    # now, pink correctly fails in garage_item_validator()
    my_garage.things.append(Tool("wrench", "pink")) # <-- pink fails

    print(my_garage)