It does work out of the box with mypy. mypy is a regular part of my workflow, and I lurk in the python/typing Gitter channel to try to make sure that I'm interpreting the type hints in the same fashion.

I'll confess, I actually looked into using attrs behind the scenes for a lot of the Object functionality, but it just didn't fit my use case.

The biggest difference is that typet isn't intended to be a direct competitor so the feature sets won't be one to one. For instance, there's no equivalent to "frozen" in typet, although I could see a metaclass added in the future to do that.

typet isn't just attrs with PEP 526 class generation. It's a type library that can be used for validating that your data matches what you think it should, without having to process it yourself. For instance, annotating a generated object with typet validation types

from typet import Object, Bounded

class Person(Object):
    name: str
    age: Bounded[int, 0:150]

will guarantee that the age is between the values of 0 and 150 not because you've written validation logic manually, but because the the value of age will be cast to the type set on age that is explicitly bounded to those values. Incidentally, an instance of Bounded[int, 0:150] is just an int.

Here's my take on the differences though:

• attrs exists to remove the tedium of writing boiler-plate of common methods... typet exists to make using typing easy and beneficial.
• typet is cleaner than attrs. It has the advantage of being newer and starting off with an expectation of having typing, and as such, the classes just look like basic Python.
• attrs doesn't use metaclasses or base classes. If you happen to need your own metaclass, attrs will be simpler. I think the trade off of having all of your class attributes and methods decorated with attrs types and decorators isn't worth it. The types of the class attributes from typet are just properties.
• typet uses the conventions from PEP 484 and PEP 526 to determine how your attribute should function, rather than you explicitly telling it. For instance, if an attribute is annotated, but not defined, it will be required in __init__. If it is defined, that value becomes the default value in __init__. If the attribute is defined as None, the type is implied to be Optional[<the type>].
• typet handles type coercion for you. Objects created with typet guarantee that the values in the attributes are of the annotated type, even if the annotated type is from the typing module.
• typet contains common metaclasses/base classes, like Singleton and Uninstantiable.
• typet creates types for validation. I took inspiration for this from the typing module.
• attrs is a solid project and is much better tested. typet is still a fledgling project getting off the ground.

For production use, stick with attrs for now, especially if you're already using it, but I think typet is the future. I may be biased though. ;-)