Handling the Bool type with type checkers

[multimeric]

The metamodel seems to have a Bool type which is weird to work with.

It's defined such that calling Bool() returns a bool so I suppose an instance of the class can never actually exist. However this doesn't help with type checkers.

So, if I want to write a custom generator:

    def visit_class_slot(self, cls: ClassDefinition, aliased_slot_name: str, slot: SlotDefinition) -> Optional[str]:
        if slot.required is not None:
            required: bool = slot.required

The pyright type checker reports:

Type "bool | Bool" is not assignable to declared type "bool"
  Type "bool | Bool" is not assignable to type "bool"
    "Bool" is not assignable to "bool"Pylance[reportAssignmentType](https://github.com/microsoft/pyright/blob/main/docs/configuration.md#reportAssignmentType)

I suppose I can do this, but it's a bit unusual:

    def visit_class_slot(self, cls: ClassDefinition, aliased_slot_name: str, slot: SlotDefinition) -> Optional[str]:
        from linkml_runtime.utils.metamodelcore import Bool
        if slot.required is not None:
            required: bool = Bool(slot.required)

[cmungall]

The decision to subclass primitive types in PythonGenerator has proven controversial. Even though this works for strings, ints, etc, it can cause confusion. When passing instances of these objects to some external tools, they may perform operations like if type(obj) == str, which will return False. Ideally everyone would use isinstance, but we can't guarantee that.

As you've noticed, there is an additional wrinkle with bools, as these can't be subclassed in the same way:

https://stackoverflow.com/questions/2172189/why-i-cant-extend-bool-in-python

We could explore changing pythongen to simply use the native bools.

However, I would recommend moving over to pydanticgen, this should play better with mypy. In pythongen we don't subclass primitives, we just use them directly, for the core types. There are a number of other advantages to pydanticgen.

[multimeric]

Right, I have noticed that the Pydantic generator produces more idiomatic code.

Even if the current generator is used, I suggest that bool | Bool is a problematic type annotation, because you always have to check the type to make the type checker happy. I suppose you meant something more like bool & Bool (intersection, not union), which doesn't exist but has been proposed. If (pseudo) subclassing is truly desired, I would prefer:

from typing import NewType
Bool = NewType("Bool", bool)

This way, type(obj) == bool will return True but it will let you distinguish LinkML bools from Python bools.