The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

This class is designed to work with UNIX batch systems like PBS, LSF,
GridEngine, etc. The overall model is that there are different commands
like qsub, qdel, etc. that handle the starting and stopping of the process.

This class also has the notion of a batch script. The batch_template
attribute can be set to a string that is a template for the batch script.
This template is instantiated using string formatting. Thus the template can
use {n} fot the number of instances. Subclasses can add additional variables
to the template dict.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.

Static handlers can be created by creating methods on a HasTraits
subclass with the naming convention ‘_[traitname]_changed’. Thus,
to create static handler for the trait ‘a’, create the method
_a_changed(self, name, old, new) (fewer arguments can be used, see
below).

Parameters :

handler : callable

A callable that is called when a trait changes. Its
signature can be handler(), handler(name), handler(name, new)
or handler(name, old, new).

name : list, str, None

If None, the handler will apply to all traits. If a list
of str, handler will apply to all names in the list. If a
str, the handler will apply just to that name.

remove : bool

If False (the default), then install the handler. If True
then unintall it.

The TraitTypes returned don’t know anything about the values
that the various HasTrait’s instances are holding.

This follows the same algorithm as traits does and does not allow
for any simple way of specifying merely that a metadata name
exists, but has any value. This is because get_metadata returns
None if a metadata key doesn’t exist.