You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2690 lines
93 KiB
2690 lines
93 KiB
# encoding: utf-8
|
|
"""
|
|
A lightweight Traits like module.
|
|
|
|
This is designed to provide a lightweight, simple, pure Python version of
|
|
many of the capabilities of enthought.traits. This includes:
|
|
|
|
* Validation
|
|
* Type specification with defaults
|
|
* Static and dynamic notification
|
|
* Basic predefined types
|
|
* An API that is similar to enthought.traits
|
|
|
|
We don't support:
|
|
|
|
* Delegation
|
|
* Automatic GUI generation
|
|
* A full set of trait types. Most importantly, we don't provide container
|
|
traits (list, dict, tuple) that can trigger notifications if their
|
|
contents change.
|
|
* API compatibility with enthought.traits
|
|
|
|
There are also some important difference in our design:
|
|
|
|
* enthought.traits does not validate default values. We do.
|
|
|
|
We choose to create this module because we need these capabilities, but
|
|
we need them to be pure Python so they work in all Python implementations,
|
|
including Jython and IronPython.
|
|
|
|
Inheritance diagram:
|
|
|
|
.. inheritance-diagram:: traitlets.traitlets
|
|
:parts: 3
|
|
"""
|
|
|
|
# Copyright (c) IPython Development Team.
|
|
# Distributed under the terms of the Modified BSD License.
|
|
#
|
|
# Adapted from enthought.traits, Copyright (c) Enthought, Inc.,
|
|
# also under the terms of the Modified BSD License.
|
|
|
|
import contextlib
|
|
import inspect
|
|
import os
|
|
import re
|
|
import sys
|
|
import types
|
|
import enum
|
|
try:
|
|
from types import ClassType, InstanceType
|
|
ClassTypes = (ClassType, type)
|
|
except:
|
|
ClassTypes = (type,)
|
|
from warnings import warn, warn_explicit
|
|
|
|
import six
|
|
|
|
from .utils.getargspec import getargspec
|
|
from .utils.importstring import import_item
|
|
from .utils.sentinel import Sentinel
|
|
from .utils.bunch import Bunch
|
|
|
|
SequenceTypes = (list, tuple, set, frozenset)
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Basic classes
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
Undefined = Sentinel('Undefined', 'traitlets',
|
|
'''
|
|
Used in Traitlets to specify that no defaults are set in kwargs
|
|
'''
|
|
)
|
|
|
|
All = Sentinel('All', 'traitlets',
|
|
'''
|
|
Used in Traitlets to listen to all types of notification or to notifications
|
|
from all trait attributes.
|
|
'''
|
|
)
|
|
|
|
# Deprecated alias
|
|
NoDefaultSpecified = Undefined
|
|
|
|
class TraitError(Exception):
|
|
pass
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Utilities
|
|
#-----------------------------------------------------------------------------
|
|
|
|
from ipython_genutils.py3compat import cast_unicode_py2
|
|
|
|
_name_re = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*$")
|
|
|
|
def isidentifier(s):
|
|
if six.PY2:
|
|
return bool(_name_re.match(s))
|
|
else:
|
|
return s.isidentifier()
|
|
|
|
_deprecations_shown = set()
|
|
def _should_warn(key):
|
|
"""Add our own checks for too many deprecation warnings.
|
|
|
|
Limit to once per package.
|
|
"""
|
|
env_flag = os.environ.get('TRAITLETS_ALL_DEPRECATIONS')
|
|
if env_flag and env_flag != '0':
|
|
return True
|
|
|
|
if key not in _deprecations_shown:
|
|
_deprecations_shown.add(key)
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def _deprecated_method(method, cls, method_name, msg):
|
|
"""Show deprecation warning about a magic method definition.
|
|
|
|
Uses warn_explicit to bind warning to method definition instead of triggering code,
|
|
which isn't relevant.
|
|
"""
|
|
warn_msg = "{classname}.{method_name} is deprecated in traitlets 4.1: {msg}".format(
|
|
classname=cls.__name__, method_name=method_name, msg=msg
|
|
)
|
|
|
|
for parent in inspect.getmro(cls):
|
|
if method_name in parent.__dict__:
|
|
cls = parent
|
|
break
|
|
# limit deprecation messages to once per package
|
|
package_name = cls.__module__.split('.', 1)[0]
|
|
key = (package_name, msg)
|
|
if not _should_warn(key):
|
|
return
|
|
try:
|
|
fname = inspect.getsourcefile(method) or "<unknown>"
|
|
lineno = inspect.getsourcelines(method)[1] or 0
|
|
except (IOError, TypeError) as e:
|
|
# Failed to inspect for some reason
|
|
warn(warn_msg + ('\n(inspection failed) %s' % e), DeprecationWarning)
|
|
else:
|
|
warn_explicit(warn_msg, DeprecationWarning, fname, lineno)
|
|
|
|
def class_of(object):
|
|
""" Returns a string containing the class name of an object with the
|
|
correct indefinite article ('a' or 'an') preceding it (e.g., 'an Image',
|
|
'a PlotValue').
|
|
"""
|
|
if isinstance( object, six.string_types ):
|
|
return add_article( object )
|
|
|
|
return add_article( object.__class__.__name__ )
|
|
|
|
|
|
def add_article(name):
|
|
""" Returns a string containing the correct indefinite article ('a' or 'an')
|
|
prefixed to the specified string.
|
|
"""
|
|
if name[:1].lower() in 'aeiou':
|
|
return 'an ' + name
|
|
|
|
return 'a ' + name
|
|
|
|
|
|
def repr_type(obj):
|
|
""" Return a string representation of a value and its type for readable
|
|
error messages.
|
|
"""
|
|
the_type = type(obj)
|
|
if six.PY2 and the_type is InstanceType:
|
|
# Old-style class.
|
|
the_type = obj.__class__
|
|
msg = '%r %r' % (obj, the_type)
|
|
return msg
|
|
|
|
|
|
def is_trait(t):
|
|
""" Returns whether the given value is an instance or subclass of TraitType.
|
|
"""
|
|
return (isinstance(t, TraitType) or
|
|
(isinstance(t, type) and issubclass(t, TraitType)))
|
|
|
|
|
|
def parse_notifier_name(names):
|
|
"""Convert the name argument to a list of names.
|
|
|
|
Examples
|
|
--------
|
|
|
|
>>> parse_notifier_name([])
|
|
[All]
|
|
>>> parse_notifier_name('a')
|
|
['a']
|
|
>>> parse_notifier_name(['a', 'b'])
|
|
['a', 'b']
|
|
>>> parse_notifier_name(All)
|
|
[All]
|
|
"""
|
|
if names is All or isinstance(names, six.string_types):
|
|
return [names]
|
|
else:
|
|
if not names or All in names:
|
|
return [All]
|
|
for n in names:
|
|
if not isinstance(n, six.string_types):
|
|
raise TypeError("names must be strings, not %r" % n)
|
|
return names
|
|
|
|
|
|
class _SimpleTest:
|
|
def __init__ ( self, value ): self.value = value
|
|
def __call__ ( self, test ):
|
|
return test == self.value
|
|
def __repr__(self):
|
|
return "<SimpleTest(%r)" % self.value
|
|
def __str__(self):
|
|
return self.__repr__()
|
|
|
|
|
|
def getmembers(object, predicate=None):
|
|
"""A safe version of inspect.getmembers that handles missing attributes.
|
|
|
|
This is useful when there are descriptor based attributes that for
|
|
some reason raise AttributeError even though they exist. This happens
|
|
in zope.inteface with the __provides__ attribute.
|
|
"""
|
|
results = []
|
|
for key in dir(object):
|
|
try:
|
|
value = getattr(object, key)
|
|
except AttributeError:
|
|
pass
|
|
else:
|
|
if not predicate or predicate(value):
|
|
results.append((key, value))
|
|
results.sort()
|
|
return results
|
|
|
|
def _validate_link(*tuples):
|
|
"""Validate arguments for traitlet link functions"""
|
|
for t in tuples:
|
|
if not len(t) == 2:
|
|
raise TypeError("Each linked traitlet must be specified as (HasTraits, 'trait_name'), not %r" % t)
|
|
obj, trait_name = t
|
|
if not isinstance(obj, HasTraits):
|
|
raise TypeError("Each object must be HasTraits, not %r" % type(obj))
|
|
if not trait_name in obj.traits():
|
|
raise TypeError("%r has no trait %r" % (obj, trait_name))
|
|
|
|
class link(object):
|
|
"""Link traits from different objects together so they remain in sync.
|
|
|
|
Parameters
|
|
----------
|
|
source : (object / attribute name) pair
|
|
target : (object / attribute name) pair
|
|
|
|
Examples
|
|
--------
|
|
|
|
>>> c = link((src, 'value'), (tgt, 'value'))
|
|
>>> src.value = 5 # updates other objects as well
|
|
"""
|
|
updating = False
|
|
|
|
def __init__(self, source, target):
|
|
_validate_link(source, target)
|
|
self.source, self.target = source, target
|
|
try:
|
|
setattr(target[0], target[1], getattr(source[0], source[1]))
|
|
finally:
|
|
source[0].observe(self._update_target, names=source[1])
|
|
target[0].observe(self._update_source, names=target[1])
|
|
|
|
@contextlib.contextmanager
|
|
def _busy_updating(self):
|
|
self.updating = True
|
|
try:
|
|
yield
|
|
finally:
|
|
self.updating = False
|
|
|
|
def _update_target(self, change):
|
|
if self.updating:
|
|
return
|
|
with self._busy_updating():
|
|
setattr(self.target[0], self.target[1], change.new)
|
|
|
|
def _update_source(self, change):
|
|
if self.updating:
|
|
return
|
|
with self._busy_updating():
|
|
setattr(self.source[0], self.source[1], change.new)
|
|
|
|
def unlink(self):
|
|
self.source[0].unobserve(self._update_target, names=self.source[1])
|
|
self.target[0].unobserve(self._update_source, names=self.target[1])
|
|
self.source, self.target = None, None
|
|
|
|
|
|
class directional_link(object):
|
|
"""Link the trait of a source object with traits of target objects.
|
|
|
|
Parameters
|
|
----------
|
|
source : (object, attribute name) pair
|
|
target : (object, attribute name) pair
|
|
transform: callable (optional)
|
|
Data transformation between source and target.
|
|
|
|
Examples
|
|
--------
|
|
|
|
>>> c = directional_link((src, 'value'), (tgt, 'value'))
|
|
>>> src.value = 5 # updates target objects
|
|
>>> tgt.value = 6 # does not update source object
|
|
"""
|
|
updating = False
|
|
|
|
def __init__(self, source, target, transform=None):
|
|
self._transform = transform if transform else lambda x: x
|
|
_validate_link(source, target)
|
|
self.source, self.target = source, target
|
|
try:
|
|
setattr(target[0], target[1],
|
|
self._transform(getattr(source[0], source[1])))
|
|
finally:
|
|
self.source[0].observe(self._update, names=self.source[1])
|
|
|
|
@contextlib.contextmanager
|
|
def _busy_updating(self):
|
|
self.updating = True
|
|
try:
|
|
yield
|
|
finally:
|
|
self.updating = False
|
|
|
|
def _update(self, change):
|
|
if self.updating:
|
|
return
|
|
with self._busy_updating():
|
|
setattr(self.target[0], self.target[1],
|
|
self._transform(change.new))
|
|
|
|
def unlink(self):
|
|
self.source[0].unobserve(self._update, names=self.source[1])
|
|
self.source, self.target = None, None
|
|
|
|
dlink = directional_link
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Base Descriptor Class
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
class BaseDescriptor(object):
|
|
"""Base descriptor class
|
|
|
|
Notes
|
|
-----
|
|
This implements Python's descriptor prototol.
|
|
|
|
This class is the base class for all such descriptors. The
|
|
only magic we use is a custom metaclass for the main :class:`HasTraits`
|
|
class that does the following:
|
|
|
|
1. Sets the :attr:`name` attribute of every :class:`BaseDescriptor`
|
|
instance in the class dict to the name of the attribute.
|
|
2. Sets the :attr:`this_class` attribute of every :class:`BaseDescriptor`
|
|
instance in the class dict to the *class* that declared the trait.
|
|
This is used by the :class:`This` trait to allow subclasses to
|
|
accept superclasses for :class:`This` values.
|
|
"""
|
|
|
|
name = None
|
|
this_class = None
|
|
|
|
def class_init(self, cls, name):
|
|
"""Part of the initialization which may depend on the underlying
|
|
HasDescriptors class.
|
|
|
|
It is typically overloaded for specific types.
|
|
|
|
This method is called by :meth:`MetaHasDescriptors.__init__`
|
|
passing the class (`cls`) and `name` under which the descriptor
|
|
has been assigned.
|
|
"""
|
|
self.this_class = cls
|
|
self.name = name
|
|
|
|
def instance_init(self, obj):
|
|
"""Part of the initialization which may depend on the underlying
|
|
HasDescriptors instance.
|
|
|
|
It is typically overloaded for specific types.
|
|
|
|
This method is called by :meth:`HasTraits.__new__` and in the
|
|
:meth:`BaseDescriptor.instance_init` method of descriptors holding
|
|
other descriptors.
|
|
"""
|
|
pass
|
|
|
|
|
|
class TraitType(BaseDescriptor):
|
|
"""A base class for all trait types.
|
|
"""
|
|
|
|
metadata = {}
|
|
default_value = Undefined
|
|
allow_none = False
|
|
read_only = False
|
|
info_text = 'any value'
|
|
|
|
def __init__(self, default_value=Undefined, allow_none=False, read_only=None, help=None,
|
|
config=None, **kwargs):
|
|
"""Declare a traitlet.
|
|
|
|
If *allow_none* is True, None is a valid value in addition to any
|
|
values that are normally valid. The default is up to the subclass.
|
|
For most trait types, the default value for ``allow_none`` is False.
|
|
|
|
Extra metadata can be associated with the traitlet using the .tag() convenience method
|
|
or by using the traitlet instance's .metadata dictionary.
|
|
"""
|
|
if default_value is not Undefined:
|
|
self.default_value = default_value
|
|
if allow_none:
|
|
self.allow_none = allow_none
|
|
if read_only is not None:
|
|
self.read_only = read_only
|
|
self.help = help if help is not None else ''
|
|
|
|
if len(kwargs) > 0:
|
|
stacklevel = 1
|
|
f = inspect.currentframe()
|
|
# count supers to determine stacklevel for warning
|
|
while f.f_code.co_name == '__init__':
|
|
stacklevel += 1
|
|
f = f.f_back
|
|
mod = f.f_globals.get('__name__') or ''
|
|
pkg = mod.split('.', 1)[0]
|
|
key = tuple(['metadata-tag', pkg] + sorted(kwargs))
|
|
if _should_warn(key):
|
|
warn("metadata %s was set from the constructor. "
|
|
"With traitlets 4.1, metadata should be set using the .tag() method, "
|
|
"e.g., Int().tag(key1='value1', key2='value2')" % (kwargs,),
|
|
DeprecationWarning, stacklevel=stacklevel)
|
|
if len(self.metadata) > 0:
|
|
self.metadata = self.metadata.copy()
|
|
self.metadata.update(kwargs)
|
|
else:
|
|
self.metadata = kwargs
|
|
else:
|
|
self.metadata = self.metadata.copy()
|
|
if config is not None:
|
|
self.metadata['config'] = config
|
|
|
|
# We add help to the metadata during a deprecation period so that
|
|
# code that looks for the help string there can find it.
|
|
if help is not None:
|
|
self.metadata['help'] = help
|
|
|
|
def get_default_value(self):
|
|
"""DEPRECATED: Retrieve the static default value for this trait.
|
|
|
|
Use self.default_value instead
|
|
"""
|
|
warn("get_default_value is deprecated in traitlets 4.0: use the .default_value attribute", DeprecationWarning,
|
|
stacklevel=2)
|
|
return self.default_value
|
|
|
|
def init_default_value(self, obj):
|
|
"""DEPRECATED: Set the static default value for the trait type.
|
|
"""
|
|
warn("init_default_value is deprecated in traitlets 4.0, and may be removed in the future", DeprecationWarning,
|
|
stacklevel=2)
|
|
value = self._validate(obj, self.default_value)
|
|
obj._trait_values[self.name] = value
|
|
return value
|
|
|
|
def _dynamic_default_callable(self, obj):
|
|
"""Retrieve a callable to calculate the default for this traitlet.
|
|
|
|
This looks for:
|
|
|
|
* default generators registered with the @default descriptor.
|
|
* obj._{name}_default() on the class with the traitlet, or a subclass
|
|
that obj belongs to.
|
|
* trait.make_dynamic_default, which is defined by Instance
|
|
|
|
If neither exist, it returns None
|
|
"""
|
|
# Traitlets without a name are not on the instance, e.g. in List or Union
|
|
if self.name:
|
|
|
|
# Only look for default handlers in classes derived from self.this_class.
|
|
mro = type(obj).mro()
|
|
meth_name = '_%s_default' % self.name
|
|
for cls in mro[:mro.index(self.this_class) + 1]:
|
|
if hasattr(cls, '_trait_default_generators'):
|
|
default_handler = cls._trait_default_generators.get(self.name)
|
|
if default_handler is not None and default_handler.this_class == cls:
|
|
return types.MethodType(default_handler.func, obj)
|
|
|
|
if meth_name in cls.__dict__:
|
|
method = getattr(obj, meth_name)
|
|
return method
|
|
|
|
return getattr(self, 'make_dynamic_default', None)
|
|
|
|
def instance_init(self, obj):
|
|
# If no dynamic initialiser is present, and the trait implementation or
|
|
# use provides a static default, transfer that to obj._trait_values.
|
|
with obj.cross_validation_lock:
|
|
if (self._dynamic_default_callable(obj) is None) \
|
|
and (self.default_value is not Undefined):
|
|
v = self._validate(obj, self.default_value)
|
|
if self.name is not None:
|
|
obj._trait_values[self.name] = v
|
|
|
|
def get(self, obj, cls=None):
|
|
try:
|
|
value = obj._trait_values[self.name]
|
|
except KeyError:
|
|
# Check for a dynamic initializer.
|
|
dynamic_default = self._dynamic_default_callable(obj)
|
|
if dynamic_default is None:
|
|
raise TraitError("No default value found for %s trait of %r"
|
|
% (self.name, obj))
|
|
value = self._validate(obj, dynamic_default())
|
|
obj._trait_values[self.name] = value
|
|
return value
|
|
except Exception:
|
|
# This should never be reached.
|
|
raise TraitError('Unexpected error in TraitType: '
|
|
'default value not set properly')
|
|
else:
|
|
return value
|
|
|
|
def __get__(self, obj, cls=None):
|
|
"""Get the value of the trait by self.name for the instance.
|
|
|
|
Default values are instantiated when :meth:`HasTraits.__new__`
|
|
is called. Thus by the time this method gets called either the
|
|
default value or a user defined value (they called :meth:`__set__`)
|
|
is in the :class:`HasTraits` instance.
|
|
"""
|
|
if obj is None:
|
|
return self
|
|
else:
|
|
return self.get(obj, cls)
|
|
|
|
def set(self, obj, value):
|
|
new_value = self._validate(obj, value)
|
|
try:
|
|
old_value = obj._trait_values[self.name]
|
|
except KeyError:
|
|
old_value = self.default_value
|
|
|
|
obj._trait_values[self.name] = new_value
|
|
try:
|
|
silent = bool(old_value == new_value)
|
|
except:
|
|
# if there is an error in comparing, default to notify
|
|
silent = False
|
|
if silent is not True:
|
|
# we explicitly compare silent to True just in case the equality
|
|
# comparison above returns something other than True/False
|
|
obj._notify_trait(self.name, old_value, new_value)
|
|
|
|
def __set__(self, obj, value):
|
|
"""Set the value of the trait by self.name for the instance.
|
|
|
|
Values pass through a validation stage where errors are raised when
|
|
impropper types, or types that cannot be coerced, are encountered.
|
|
"""
|
|
if self.read_only:
|
|
raise TraitError('The "%s" trait is read-only.' % self.name)
|
|
else:
|
|
self.set(obj, value)
|
|
|
|
def _validate(self, obj, value):
|
|
if value is None and self.allow_none:
|
|
return value
|
|
if hasattr(self, 'validate'):
|
|
value = self.validate(obj, value)
|
|
if obj._cross_validation_lock is False:
|
|
value = self._cross_validate(obj, value)
|
|
return value
|
|
|
|
def _cross_validate(self, obj, value):
|
|
if self.name in obj._trait_validators:
|
|
proposal = Bunch({'trait': self, 'value': value, 'owner': obj})
|
|
value = obj._trait_validators[self.name](obj, proposal)
|
|
elif hasattr(obj, '_%s_validate' % self.name):
|
|
meth_name = '_%s_validate' % self.name
|
|
cross_validate = getattr(obj, meth_name)
|
|
_deprecated_method(cross_validate, obj.__class__, meth_name,
|
|
"use @validate decorator instead.")
|
|
value = cross_validate(value, self)
|
|
return value
|
|
|
|
def __or__(self, other):
|
|
if isinstance(other, Union):
|
|
return Union([self] + other.trait_types)
|
|
else:
|
|
return Union([self, other])
|
|
|
|
def info(self):
|
|
return self.info_text
|
|
|
|
def error(self, obj, value):
|
|
if obj is not None:
|
|
e = "The '%s' trait of %s instance must be %s, but a value of %s was specified." \
|
|
% (self.name, class_of(obj),
|
|
self.info(), repr_type(value))
|
|
else:
|
|
e = "The '%s' trait must be %s, but a value of %r was specified." \
|
|
% (self.name, self.info(), repr_type(value))
|
|
raise TraitError(e)
|
|
|
|
def get_metadata(self, key, default=None):
|
|
"""DEPRECATED: Get a metadata value.
|
|
|
|
Use .metadata[key] or .metadata.get(key, default) instead.
|
|
"""
|
|
if key == 'help':
|
|
msg = "use the instance .help string directly, like x.help"
|
|
else:
|
|
msg = "use the instance .metadata dictionary directly, like x.metadata[key] or x.metadata.get(key, default)"
|
|
warn("Deprecated in traitlets 4.1, " + msg, DeprecationWarning, stacklevel=2)
|
|
return self.metadata.get(key, default)
|
|
|
|
def set_metadata(self, key, value):
|
|
"""DEPRECATED: Set a metadata key/value.
|
|
|
|
Use .metadata[key] = value instead.
|
|
"""
|
|
if key == 'help':
|
|
msg = "use the instance .help string directly, like x.help = value"
|
|
else:
|
|
msg = "use the instance .metadata dictionary directly, like x.metadata[key] = value"
|
|
warn("Deprecated in traitlets 4.1, " + msg, DeprecationWarning, stacklevel=2)
|
|
self.metadata[key] = value
|
|
|
|
def tag(self, **metadata):
|
|
"""Sets metadata and returns self.
|
|
|
|
This allows convenient metadata tagging when initializing the trait, such as:
|
|
|
|
>>> Int(0).tag(config=True, sync=True)
|
|
"""
|
|
maybe_constructor_keywords = set(metadata.keys()).intersection({'help','allow_none', 'read_only', 'default_value'})
|
|
if maybe_constructor_keywords:
|
|
warn('The following attributes are set in using `tag`, but seem to be constructor keywords arguments: %s '%
|
|
maybe_constructor_keywords, UserWarning, stacklevel=2)
|
|
|
|
self.metadata.update(metadata)
|
|
return self
|
|
|
|
def default_value_repr(self):
|
|
return repr(self.default_value)
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# The HasTraits implementation
|
|
#-----------------------------------------------------------------------------
|
|
|
|
class _CallbackWrapper(object):
|
|
"""An object adapting a on_trait_change callback into an observe callback.
|
|
|
|
The comparison operator __eq__ is implemented to enable removal of wrapped
|
|
callbacks.
|
|
"""
|
|
|
|
def __init__(self, cb):
|
|
self.cb = cb
|
|
# Bound methods have an additional 'self' argument.
|
|
offset = -1 if isinstance(self.cb, types.MethodType) else 0
|
|
self.nargs = len(getargspec(cb)[0]) + offset
|
|
if (self.nargs > 4):
|
|
raise TraitError('a trait changed callback must have 0-4 arguments.')
|
|
|
|
def __eq__(self, other):
|
|
# The wrapper is equal to the wrapped element
|
|
if isinstance(other, _CallbackWrapper):
|
|
return self.cb == other.cb
|
|
else:
|
|
return self.cb == other
|
|
|
|
def __call__(self, change):
|
|
# The wrapper is callable
|
|
if self.nargs == 0:
|
|
self.cb()
|
|
elif self.nargs == 1:
|
|
self.cb(change.name)
|
|
elif self.nargs == 2:
|
|
self.cb(change.name, change.new)
|
|
elif self.nargs == 3:
|
|
self.cb(change.name, change.old, change.new)
|
|
elif self.nargs == 4:
|
|
self.cb(change.name, change.old, change.new, change.owner)
|
|
|
|
def _callback_wrapper(cb):
|
|
if isinstance(cb, _CallbackWrapper):
|
|
return cb
|
|
else:
|
|
return _CallbackWrapper(cb)
|
|
|
|
|
|
class MetaHasDescriptors(type):
|
|
"""A metaclass for HasDescriptors.
|
|
|
|
This metaclass makes sure that any TraitType class attributes are
|
|
instantiated and sets their name attribute.
|
|
"""
|
|
|
|
def __new__(mcls, name, bases, classdict):
|
|
"""Create the HasDescriptors class."""
|
|
for k, v in classdict.items():
|
|
# ----------------------------------------------------------------
|
|
# Support of deprecated behavior allowing for TraitType types
|
|
# to be used instead of TraitType instances.
|
|
if inspect.isclass(v) and issubclass(v, TraitType):
|
|
warn("Traits should be given as instances, not types (for example, `Int()`, not `Int`)."
|
|
" Passing types is deprecated in traitlets 4.1.",
|
|
DeprecationWarning, stacklevel=2)
|
|
classdict[k] = v()
|
|
# ----------------------------------------------------------------
|
|
|
|
return super(MetaHasDescriptors, mcls).__new__(mcls, name, bases, classdict)
|
|
|
|
def __init__(cls, name, bases, classdict):
|
|
"""Finish initializing the HasDescriptors class."""
|
|
super(MetaHasDescriptors, cls).__init__(name, bases, classdict)
|
|
cls.setup_class(classdict)
|
|
|
|
def setup_class(cls, classdict):
|
|
"""Setup descriptor instance on the class
|
|
|
|
This sets the :attr:`this_class` and :attr:`name` attributes of each
|
|
BaseDescriptor in the class dict of the newly created ``cls`` before
|
|
calling their :attr:`class_init` method.
|
|
"""
|
|
for k, v in classdict.items():
|
|
if isinstance(v, BaseDescriptor):
|
|
v.class_init(cls, k)
|
|
|
|
|
|
class MetaHasTraits(MetaHasDescriptors):
|
|
"""A metaclass for HasTraits."""
|
|
|
|
def setup_class(cls, classdict):
|
|
cls._trait_default_generators = {}
|
|
super(MetaHasTraits, cls).setup_class(classdict)
|
|
|
|
|
|
def observe(*names, **kwargs):
|
|
"""A decorator which can be used to observe Traits on a class.
|
|
|
|
The handler passed to the decorator will be called with one ``change``
|
|
dict argument. The change dictionary at least holds a 'type' key and a
|
|
'name' key, corresponding respectively to the type of notification and the
|
|
name of the attribute that triggered the notification.
|
|
|
|
Other keys may be passed depending on the value of 'type'. In the case
|
|
where type is 'change', we also have the following keys:
|
|
* ``owner`` : the HasTraits instance
|
|
* ``old`` : the old value of the modified trait attribute
|
|
* ``new`` : the new value of the modified trait attribute
|
|
* ``name`` : the name of the modified trait attribute.
|
|
|
|
Parameters
|
|
----------
|
|
*names
|
|
The str names of the Traits to observe on the object.
|
|
type: str, kwarg-only
|
|
The type of event to observe (e.g. 'change')
|
|
"""
|
|
if not names:
|
|
raise TypeError("Please specify at least one trait name to observe.")
|
|
for name in names:
|
|
if name is not All and not isinstance(name, six.string_types):
|
|
raise TypeError("trait names to observe must be strings or All, not %r" % name)
|
|
return ObserveHandler(names, type=kwargs.get('type', 'change'))
|
|
|
|
|
|
def observe_compat(func):
|
|
"""Backward-compatibility shim decorator for observers
|
|
|
|
Use with:
|
|
|
|
@observe('name')
|
|
@observe_compat
|
|
def _foo_changed(self, change):
|
|
...
|
|
|
|
With this, `super()._foo_changed(self, name, old, new)` in subclasses will still work.
|
|
Allows adoption of new observer API without breaking subclasses that override and super.
|
|
"""
|
|
def compatible_observer(self, change_or_name, old=Undefined, new=Undefined):
|
|
if isinstance(change_or_name, dict):
|
|
change = change_or_name
|
|
else:
|
|
clsname = self.__class__.__name__
|
|
warn("A parent of %s._%s_changed has adopted the new (traitlets 4.1) @observe(change) API" % (
|
|
clsname, change_or_name), DeprecationWarning)
|
|
change = Bunch(
|
|
type='change',
|
|
old=old,
|
|
new=new,
|
|
name=change_or_name,
|
|
owner=self,
|
|
)
|
|
return func(self, change)
|
|
return compatible_observer
|
|
|
|
|
|
def validate(*names):
|
|
"""A decorator to register cross validator of HasTraits object's state
|
|
when a Trait is set.
|
|
|
|
The handler passed to the decorator must have one ``proposal`` dict argument.
|
|
The proposal dictionary must hold the following keys:
|
|
* ``owner`` : the HasTraits instance
|
|
* ``value`` : the proposed value for the modified trait attribute
|
|
* ``trait`` : the TraitType instance associated with the attribute
|
|
|
|
Parameters
|
|
----------
|
|
names
|
|
The str names of the Traits to validate.
|
|
|
|
Notes
|
|
-----
|
|
Since the owner has access to the ``HasTraits`` instance via the 'owner' key,
|
|
the registered cross validator could potentially make changes to attributes
|
|
of the ``HasTraits`` instance. However, we recommend not to do so. The reason
|
|
is that the cross-validation of attributes may run in arbitrary order when
|
|
exiting the ``hold_trait_notifications`` context, and such changes may not
|
|
commute.
|
|
"""
|
|
if not names:
|
|
raise TypeError("Please specify at least one trait name to validate.")
|
|
for name in names:
|
|
if name is not All and not isinstance(name, six.string_types):
|
|
raise TypeError("trait names to validate must be strings or All, not %r" % name)
|
|
return ValidateHandler(names)
|
|
|
|
|
|
def default(name):
|
|
""" A decorator which assigns a dynamic default for a Trait on a HasTraits object.
|
|
|
|
Parameters
|
|
----------
|
|
name
|
|
The str name of the Trait on the object whose default should be generated.
|
|
|
|
Notes
|
|
-----
|
|
Unlike observers and validators which are properties of the HasTraits
|
|
instance, default value generators are class-level properties.
|
|
|
|
Besides, default generators are only invoked if they are registered in
|
|
subclasses of `this_type`.
|
|
|
|
::
|
|
|
|
class A(HasTraits):
|
|
bar = Int()
|
|
|
|
@default('bar')
|
|
def get_bar_default(self):
|
|
return 11
|
|
|
|
|
|
class B(A):
|
|
bar = Float() # This trait ignores the default generator defined in
|
|
# the base class A
|
|
|
|
|
|
class C(B):
|
|
|
|
@default('bar')
|
|
def some_other_default(self): # This default generator should not be
|
|
return 3.0 # ignored since it is defined in a
|
|
# class derived from B.a.this_class.
|
|
"""
|
|
if not isinstance(name, six.string_types):
|
|
raise TypeError("Trait name must be a string or All, not %r" % name)
|
|
return DefaultHandler(name)
|
|
|
|
|
|
class EventHandler(BaseDescriptor):
|
|
|
|
def _init_call(self, func):
|
|
self.func = func
|
|
return self
|
|
|
|
def __call__(self, *args, **kwargs):
|
|
"""Pass `*args` and `**kwargs` to the handler's function if it exists."""
|
|
if hasattr(self, 'func'):
|
|
return self.func(*args, **kwargs)
|
|
else:
|
|
return self._init_call(*args, **kwargs)
|
|
|
|
def __get__(self, inst, cls=None):
|
|
if inst is None:
|
|
return self
|
|
return types.MethodType(self.func, inst)
|
|
|
|
|
|
class ObserveHandler(EventHandler):
|
|
|
|
def __init__(self, names, type):
|
|
self.trait_names = names
|
|
self.type = type
|
|
|
|
def instance_init(self, inst):
|
|
inst.observe(self, self.trait_names, type=self.type)
|
|
|
|
|
|
class ValidateHandler(EventHandler):
|
|
|
|
def __init__(self, names):
|
|
self.trait_names = names
|
|
|
|
def instance_init(self, inst):
|
|
inst._register_validator(self, self.trait_names)
|
|
|
|
|
|
class DefaultHandler(EventHandler):
|
|
|
|
def __init__(self, name):
|
|
self.trait_name = name
|
|
|
|
def class_init(self, cls, name):
|
|
super(DefaultHandler, self).class_init(cls, name)
|
|
cls._trait_default_generators[self.trait_name] = self
|
|
|
|
|
|
class HasDescriptors(six.with_metaclass(MetaHasDescriptors, object)):
|
|
"""The base class for all classes that have descriptors.
|
|
"""
|
|
|
|
def __new__(cls, *args, **kwargs):
|
|
# This is needed because object.__new__ only accepts
|
|
# the cls argument.
|
|
new_meth = super(HasDescriptors, cls).__new__
|
|
if new_meth is object.__new__:
|
|
inst = new_meth(cls)
|
|
else:
|
|
inst = new_meth(cls, *args, **kwargs)
|
|
inst.setup_instance(*args, **kwargs)
|
|
return inst
|
|
|
|
def setup_instance(self, *args, **kwargs):
|
|
"""
|
|
This is called **before** self.__init__ is called.
|
|
"""
|
|
self._cross_validation_lock = False
|
|
cls = self.__class__
|
|
for key in dir(cls):
|
|
# Some descriptors raise AttributeError like zope.interface's
|
|
# __provides__ attributes even though they exist. This causes
|
|
# AttributeErrors even though they are listed in dir(cls).
|
|
try:
|
|
value = getattr(cls, key)
|
|
except AttributeError:
|
|
pass
|
|
else:
|
|
if isinstance(value, BaseDescriptor):
|
|
value.instance_init(self)
|
|
|
|
|
|
class HasTraits(six.with_metaclass(MetaHasTraits, HasDescriptors)):
|
|
|
|
def setup_instance(self, *args, **kwargs):
|
|
self._trait_values = {}
|
|
self._trait_notifiers = {}
|
|
self._trait_validators = {}
|
|
super(HasTraits, self).setup_instance(*args, **kwargs)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
# Allow trait values to be set using keyword arguments.
|
|
# We need to use setattr for this to trigger validation and
|
|
# notifications.
|
|
super_args = args
|
|
super_kwargs = {}
|
|
with self.hold_trait_notifications():
|
|
for key, value in kwargs.items():
|
|
if self.has_trait(key):
|
|
setattr(self, key, value)
|
|
else:
|
|
# passthrough args that don't set traits to super
|
|
super_kwargs[key] = value
|
|
try:
|
|
super(HasTraits, self).__init__(*super_args, **super_kwargs)
|
|
except TypeError as e:
|
|
arg_s_list = [ repr(arg) for arg in super_args ]
|
|
for k, v in super_kwargs.items():
|
|
arg_s_list.append("%s=%r" % (k, v))
|
|
arg_s = ', '.join(arg_s_list)
|
|
warn(
|
|
"Passing unrecoginized arguments to super({classname}).__init__({arg_s}).\n"
|
|
"{error}\n"
|
|
"This is deprecated in traitlets 4.2."
|
|
"This error will be raised in a future release of traitlets."
|
|
.format(
|
|
arg_s=arg_s, classname=self.__class__.__name__,
|
|
error=e,
|
|
),
|
|
DeprecationWarning,
|
|
stacklevel=2,
|
|
)
|
|
|
|
def __getstate__(self):
|
|
d = self.__dict__.copy()
|
|
# event handlers stored on an instance are
|
|
# expected to be reinstantiated during a
|
|
# recall of instance_init during __setstate__
|
|
d['_trait_notifiers'] = {}
|
|
d['_trait_validators'] = {}
|
|
return d
|
|
|
|
def __setstate__(self, state):
|
|
self.__dict__ = state.copy()
|
|
|
|
# event handlers are reassigned to self
|
|
cls = self.__class__
|
|
for key in dir(cls):
|
|
# Some descriptors raise AttributeError like zope.interface's
|
|
# __provides__ attributes even though they exist. This causes
|
|
# AttributeErrors even though they are listed in dir(cls).
|
|
try:
|
|
value = getattr(cls, key)
|
|
except AttributeError:
|
|
pass
|
|
else:
|
|
if isinstance(value, EventHandler):
|
|
value.instance_init(self)
|
|
|
|
@property
|
|
@contextlib.contextmanager
|
|
def cross_validation_lock(self):
|
|
"""
|
|
A contextmanager for running a block with our cross validation lock set
|
|
to True.
|
|
|
|
At the end of the block, the lock's value is restored to its value
|
|
prior to entering the block.
|
|
"""
|
|
if self._cross_validation_lock:
|
|
yield
|
|
return
|
|
else:
|
|
try:
|
|
self._cross_validation_lock = True
|
|
yield
|
|
finally:
|
|
self._cross_validation_lock = False
|
|
|
|
@contextlib.contextmanager
|
|
def hold_trait_notifications(self):
|
|
"""Context manager for bundling trait change notifications and cross
|
|
validation.
|
|
|
|
Use this when doing multiple trait assignments (init, config), to avoid
|
|
race conditions in trait notifiers requesting other trait values.
|
|
All trait notifications will fire after all values have been assigned.
|
|
"""
|
|
if self._cross_validation_lock:
|
|
yield
|
|
return
|
|
else:
|
|
cache = {}
|
|
notify_change = self.notify_change
|
|
|
|
def compress(past_changes, change):
|
|
"""Merges the provided change with the last if possible."""
|
|
if past_changes is None:
|
|
return [change]
|
|
else:
|
|
if past_changes[-1]['type'] == 'change' and change.type == 'change':
|
|
past_changes[-1]['new'] = change.new
|
|
else:
|
|
# In case of changes other than 'change', append the notification.
|
|
past_changes.append(change)
|
|
return past_changes
|
|
|
|
def hold(change):
|
|
name = change.name
|
|
cache[name] = compress(cache.get(name), change)
|
|
|
|
try:
|
|
# Replace notify_change with `hold`, caching and compressing
|
|
# notifications, disable cross validation and yield.
|
|
self.notify_change = hold
|
|
self._cross_validation_lock = True
|
|
yield
|
|
# Cross validate final values when context is released.
|
|
for name in list(cache.keys()):
|
|
trait = getattr(self.__class__, name)
|
|
value = trait._cross_validate(self, getattr(self, name))
|
|
self.set_trait(name, value)
|
|
except TraitError as e:
|
|
# Roll back in case of TraitError during final cross validation.
|
|
self.notify_change = lambda x: None
|
|
for name, changes in cache.items():
|
|
for change in changes[::-1]:
|
|
# TODO: Separate in a rollback function per notification type.
|
|
if change.type == 'change':
|
|
if change.old is not Undefined:
|
|
self.set_trait(name, change.old)
|
|
else:
|
|
self._trait_values.pop(name)
|
|
cache = {}
|
|
raise e
|
|
finally:
|
|
self._cross_validation_lock = False
|
|
# Restore method retrieval from class
|
|
del self.notify_change
|
|
|
|
# trigger delayed notifications
|
|
for changes in cache.values():
|
|
for change in changes:
|
|
self.notify_change(change)
|
|
|
|
def _notify_trait(self, name, old_value, new_value):
|
|
self.notify_change(Bunch(
|
|
name=name,
|
|
old=old_value,
|
|
new=new_value,
|
|
owner=self,
|
|
type='change',
|
|
))
|
|
|
|
def notify_change(self, change):
|
|
if not isinstance(change, Bunch):
|
|
# cast to bunch if given a dict
|
|
change = Bunch(change)
|
|
name, type = change.name, change.type
|
|
|
|
callables = []
|
|
callables.extend(self._trait_notifiers.get(name, {}).get(type, []))
|
|
callables.extend(self._trait_notifiers.get(name, {}).get(All, []))
|
|
callables.extend(self._trait_notifiers.get(All, {}).get(type, []))
|
|
callables.extend(self._trait_notifiers.get(All, {}).get(All, []))
|
|
|
|
# Now static ones
|
|
magic_name = '_%s_changed' % name
|
|
if hasattr(self, magic_name):
|
|
class_value = getattr(self.__class__, magic_name)
|
|
if not isinstance(class_value, ObserveHandler):
|
|
_deprecated_method(class_value, self.__class__, magic_name,
|
|
"use @observe and @unobserve instead.")
|
|
cb = getattr(self, magic_name)
|
|
# Only append the magic method if it was not manually registered
|
|
if cb not in callables:
|
|
callables.append(_callback_wrapper(cb))
|
|
|
|
# Call them all now
|
|
# Traits catches and logs errors here. I allow them to raise
|
|
for c in callables:
|
|
# Bound methods have an additional 'self' argument.
|
|
|
|
if isinstance(c, _CallbackWrapper):
|
|
c = c.__call__
|
|
elif isinstance(c, EventHandler) and c.name is not None:
|
|
c = getattr(self, c.name)
|
|
|
|
c(change)
|
|
|
|
def _add_notifiers(self, handler, name, type):
|
|
if name not in self._trait_notifiers:
|
|
nlist = []
|
|
self._trait_notifiers[name] = {type: nlist}
|
|
else:
|
|
if type not in self._trait_notifiers[name]:
|
|
nlist = []
|
|
self._trait_notifiers[name][type] = nlist
|
|
else:
|
|
nlist = self._trait_notifiers[name][type]
|
|
if handler not in nlist:
|
|
nlist.append(handler)
|
|
|
|
def _remove_notifiers(self, handler, name, type):
|
|
try:
|
|
if handler is None:
|
|
del self._trait_notifiers[name][type]
|
|
else:
|
|
self._trait_notifiers[name][type].remove(handler)
|
|
except KeyError:
|
|
pass
|
|
|
|
def on_trait_change(self, handler=None, name=None, remove=False):
|
|
"""DEPRECATED: Setup a handler to be called when a trait changes.
|
|
|
|
This is used to setup dynamic notifications of trait changes.
|
|
|
|
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).
|
|
|
|
If `remove` is True and `handler` is not specified, all change
|
|
handlers for the specified name are uninstalled.
|
|
|
|
Parameters
|
|
----------
|
|
handler : callable, None
|
|
A callable that is called when a trait changes. Its
|
|
signature can be handler(), handler(name), handler(name, new),
|
|
handler(name, old, new), or handler(name, old, new, self).
|
|
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.
|
|
"""
|
|
warn("on_trait_change is deprecated in traitlets 4.1: use observe instead",
|
|
DeprecationWarning, stacklevel=2)
|
|
if name is None:
|
|
name = All
|
|
if remove:
|
|
self.unobserve(_callback_wrapper(handler), names=name)
|
|
else:
|
|
self.observe(_callback_wrapper(handler), names=name)
|
|
|
|
def observe(self, handler, names=All, type='change'):
|
|
"""Setup a handler to be called when a trait changes.
|
|
|
|
This is used to setup dynamic notifications of trait changes.
|
|
|
|
Parameters
|
|
----------
|
|
handler : callable
|
|
A callable that is called when a trait changes. Its
|
|
signature should be ``handler(change)``, where ``change`` is a
|
|
dictionary. The change dictionary at least holds a 'type' key.
|
|
* ``type``: the type of notification.
|
|
Other keys may be passed depending on the value of 'type'. In the
|
|
case where type is 'change', we also have the following keys:
|
|
* ``owner`` : the HasTraits instance
|
|
* ``old`` : the old value of the modified trait attribute
|
|
* ``new`` : the new value of the modified trait attribute
|
|
* ``name`` : the name of the modified trait attribute.
|
|
names : list, str, All
|
|
If names is All, 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.
|
|
type : str, All (default: 'change')
|
|
The type of notification to filter by. If equal to All, then all
|
|
notifications are passed to the observe handler.
|
|
"""
|
|
names = parse_notifier_name(names)
|
|
for n in names:
|
|
self._add_notifiers(handler, n, type)
|
|
|
|
def unobserve(self, handler, names=All, type='change'):
|
|
"""Remove a trait change handler.
|
|
|
|
This is used to unregister handlers to trait change notifications.
|
|
|
|
Parameters
|
|
----------
|
|
handler : callable
|
|
The callable called when a trait attribute changes.
|
|
names : list, str, All (default: All)
|
|
The names of the traits for which the specified handler should be
|
|
uninstalled. If names is All, the specified handler is uninstalled
|
|
from the list of notifiers corresponding to all changes.
|
|
type : str or All (default: 'change')
|
|
The type of notification to filter by. If All, the specified handler
|
|
is uninstalled from the list of notifiers corresponding to all types.
|
|
"""
|
|
names = parse_notifier_name(names)
|
|
for n in names:
|
|
self._remove_notifiers(handler, n, type)
|
|
|
|
def unobserve_all(self, name=All):
|
|
"""Remove trait change handlers of any type for the specified name.
|
|
If name is not specified, removes all trait notifiers."""
|
|
if name is All:
|
|
self._trait_notifiers = {}
|
|
else:
|
|
try:
|
|
del self._trait_notifiers[name]
|
|
except KeyError:
|
|
pass
|
|
|
|
def _register_validator(self, handler, names):
|
|
"""Setup a handler to be called when a trait should be cross validated.
|
|
|
|
This is used to setup dynamic notifications for cross-validation.
|
|
|
|
If a validator is already registered for any of the provided names, a
|
|
TraitError is raised and no new validator is registered.
|
|
|
|
Parameters
|
|
----------
|
|
handler : callable
|
|
A callable that is called when the given trait is cross-validated.
|
|
Its signature is handler(proposal), where proposal is a Bunch (dictionary with attribute access)
|
|
with the following attributes/keys:
|
|
* ``owner`` : the HasTraits instance
|
|
* ``value`` : the proposed value for the modified trait attribute
|
|
* ``trait`` : the TraitType instance associated with the attribute
|
|
names : List of strings
|
|
The names of the traits that should be cross-validated
|
|
"""
|
|
for name in names:
|
|
magic_name = '_%s_validate' % name
|
|
if hasattr(self, magic_name):
|
|
class_value = getattr(self.__class__, magic_name)
|
|
if not isinstance(class_value, ValidateHandler):
|
|
_deprecated_method(class_value, self.__class, magic_name,
|
|
"use @validate decorator instead.")
|
|
for name in names:
|
|
self._trait_validators[name] = handler
|
|
|
|
def add_traits(self, **traits):
|
|
"""Dynamically add trait attributes to the HasTraits instance."""
|
|
self.__class__ = type(self.__class__.__name__, (self.__class__,),
|
|
traits)
|
|
for trait in traits.values():
|
|
trait.instance_init(self)
|
|
|
|
def set_trait(self, name, value):
|
|
"""Forcibly sets trait attribute, including read-only attributes."""
|
|
cls = self.__class__
|
|
if not self.has_trait(name):
|
|
raise TraitError("Class %s does not have a trait named %s" %
|
|
(cls.__name__, name))
|
|
else:
|
|
getattr(cls, name).set(self, value)
|
|
|
|
@classmethod
|
|
def class_trait_names(cls, **metadata):
|
|
"""Get a list of all the names of this class' traits.
|
|
|
|
This method is just like the :meth:`trait_names` method,
|
|
but is unbound.
|
|
"""
|
|
return list(cls.class_traits(**metadata))
|
|
|
|
@classmethod
|
|
def class_traits(cls, **metadata):
|
|
"""Get a ``dict`` of all the traits of this class. The dictionary
|
|
is keyed on the name and the values are the TraitType objects.
|
|
|
|
This method is just like the :meth:`traits` method, but is unbound.
|
|
|
|
The TraitTypes returned don't know anything about the values
|
|
that the various HasTrait's instances are holding.
|
|
|
|
The metadata kwargs allow functions to be passed in which
|
|
filter traits based on metadata values. The functions should
|
|
take a single value as an argument and return a boolean. If
|
|
any function returns False, then the trait is not included in
|
|
the output. If a metadata key doesn't exist, None will be passed
|
|
to the function.
|
|
"""
|
|
traits = dict([memb for memb in getmembers(cls) if
|
|
isinstance(memb[1], TraitType)])
|
|
|
|
if len(metadata) == 0:
|
|
return traits
|
|
|
|
result = {}
|
|
for name, trait in traits.items():
|
|
for meta_name, meta_eval in metadata.items():
|
|
if type(meta_eval) is not types.FunctionType:
|
|
meta_eval = _SimpleTest(meta_eval)
|
|
if not meta_eval(trait.metadata.get(meta_name, None)):
|
|
break
|
|
else:
|
|
result[name] = trait
|
|
|
|
return result
|
|
|
|
@classmethod
|
|
def class_own_traits(cls, **metadata):
|
|
"""Get a dict of all the traitlets defined on this class, not a parent.
|
|
|
|
Works like `class_traits`, except for excluding traits from parents.
|
|
"""
|
|
sup = super(cls, cls)
|
|
return {n: t for (n, t) in cls.class_traits(**metadata).items()
|
|
if getattr(sup, n, None) is not t}
|
|
|
|
def has_trait(self, name):
|
|
"""Returns True if the object has a trait with the specified name."""
|
|
return isinstance(getattr(self.__class__, name, None), TraitType)
|
|
|
|
def trait_names(self, **metadata):
|
|
"""Get a list of all the names of this class' traits."""
|
|
return list(self.traits(**metadata))
|
|
|
|
def traits(self, **metadata):
|
|
"""Get a ``dict`` of all the traits of this class. The dictionary
|
|
is keyed on the name and the values are the TraitType objects.
|
|
|
|
The TraitTypes returned don't know anything about the values
|
|
that the various HasTrait's instances are holding.
|
|
|
|
The metadata kwargs allow functions to be passed in which
|
|
filter traits based on metadata values. The functions should
|
|
take a single value as an argument and return a boolean. If
|
|
any function returns False, then the trait is not included in
|
|
the output. If a metadata key doesn't exist, None will be passed
|
|
to the function.
|
|
"""
|
|
traits = dict([memb for memb in getmembers(self.__class__) if
|
|
isinstance(memb[1], TraitType)])
|
|
|
|
if len(metadata) == 0:
|
|
return traits
|
|
|
|
result = {}
|
|
for name, trait in traits.items():
|
|
for meta_name, meta_eval in metadata.items():
|
|
if type(meta_eval) is not types.FunctionType:
|
|
meta_eval = _SimpleTest(meta_eval)
|
|
if not meta_eval(trait.metadata.get(meta_name, None)):
|
|
break
|
|
else:
|
|
result[name] = trait
|
|
|
|
return result
|
|
|
|
def trait_metadata(self, traitname, key, default=None):
|
|
"""Get metadata values for trait by key."""
|
|
try:
|
|
trait = getattr(self.__class__, traitname)
|
|
except AttributeError:
|
|
raise TraitError("Class %s does not have a trait named %s" %
|
|
(self.__class__.__name__, traitname))
|
|
metadata_name = '_' + traitname + '_metadata'
|
|
if hasattr(self, metadata_name) and key in getattr(self, metadata_name):
|
|
return getattr(self, metadata_name).get(key, default)
|
|
else:
|
|
return trait.metadata.get(key, default)
|
|
|
|
@classmethod
|
|
def class_own_trait_events(cls, name):
|
|
"""Get a dict of all event handlers defined on this class, not a parent.
|
|
|
|
Works like ``event_handlers``, except for excluding traits from parents.
|
|
"""
|
|
sup = super(cls, cls)
|
|
return {n: e for (n, e) in cls.events(name).items()
|
|
if getattr(sup, n, None) is not e}
|
|
|
|
@classmethod
|
|
def trait_events(cls, name=None):
|
|
"""Get a ``dict`` of all the event handlers of this class.
|
|
|
|
Parameters
|
|
----------
|
|
name: str (default: None)
|
|
The name of a trait of this class. If name is ``None`` then all
|
|
the event handlers of this class will be returned instead.
|
|
|
|
Returns
|
|
-------
|
|
The event handlers associated with a trait name, or all event handlers.
|
|
"""
|
|
events = {}
|
|
for k, v in getmembers(cls):
|
|
if isinstance(v, EventHandler):
|
|
if name is None:
|
|
events[k] = v
|
|
elif name in v.trait_names:
|
|
events[k] = v
|
|
elif hasattr(v, 'tags'):
|
|
if cls.trait_names(**v.tags):
|
|
events[k] = v
|
|
return events
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Actual TraitTypes implementations/subclasses
|
|
#-----------------------------------------------------------------------------
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# TraitTypes subclasses for handling classes and instances of classes
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
class ClassBasedTraitType(TraitType):
|
|
"""
|
|
A trait with error reporting and string -> type resolution for Type,
|
|
Instance and This.
|
|
"""
|
|
|
|
def _resolve_string(self, string):
|
|
"""
|
|
Resolve a string supplied for a type into an actual object.
|
|
"""
|
|
return import_item(string)
|
|
|
|
def error(self, obj, value):
|
|
kind = type(value)
|
|
if six.PY2 and kind is InstanceType:
|
|
msg = 'class %s' % value.__class__.__name__
|
|
else:
|
|
msg = '%s (i.e. %s)' % ( str( kind )[1:-1], repr( value ) )
|
|
|
|
if obj is not None:
|
|
e = "The '%s' trait of %s instance must be %s, but a value of %s was specified." \
|
|
% (self.name, class_of(obj),
|
|
self.info(), msg)
|
|
else:
|
|
e = "The '%s' trait must be %s, but a value of %r was specified." \
|
|
% (self.name, self.info(), msg)
|
|
|
|
raise TraitError(e)
|
|
|
|
|
|
class Type(ClassBasedTraitType):
|
|
"""A trait whose value must be a subclass of a specified class."""
|
|
|
|
def __init__ (self, default_value=Undefined, klass=None, **kwargs):
|
|
"""Construct a Type trait
|
|
|
|
A Type trait specifies that its values must be subclasses of
|
|
a particular class.
|
|
|
|
If only ``default_value`` is given, it is used for the ``klass`` as
|
|
well. If neither are given, both default to ``object``.
|
|
|
|
Parameters
|
|
----------
|
|
default_value : class, str or None
|
|
The default value must be a subclass of klass. If an str,
|
|
the str must be a fully specified class name, like 'foo.bar.Bah'.
|
|
The string is resolved into real class, when the parent
|
|
:class:`HasTraits` class is instantiated.
|
|
klass : class, str [ default object ]
|
|
Values of this trait must be a subclass of klass. The klass
|
|
may be specified in a string like: 'foo.bar.MyClass'.
|
|
The string is resolved into real class, when the parent
|
|
:class:`HasTraits` class is instantiated.
|
|
allow_none : bool [ default False ]
|
|
Indicates whether None is allowed as an assignable value.
|
|
"""
|
|
if default_value is Undefined:
|
|
new_default_value = object if (klass is None) else klass
|
|
else:
|
|
new_default_value = default_value
|
|
|
|
if klass is None:
|
|
if (default_value is None) or (default_value is Undefined):
|
|
klass = object
|
|
else:
|
|
klass = default_value
|
|
|
|
if not (inspect.isclass(klass) or isinstance(klass, six.string_types)):
|
|
raise TraitError("A Type trait must specify a class.")
|
|
|
|
self.klass = klass
|
|
|
|
super(Type, self).__init__(new_default_value, **kwargs)
|
|
|
|
def validate(self, obj, value):
|
|
"""Validates that the value is a valid object instance."""
|
|
if isinstance(value, six.string_types):
|
|
try:
|
|
value = self._resolve_string(value)
|
|
except ImportError:
|
|
raise TraitError("The '%s' trait of %s instance must be a type, but "
|
|
"%r could not be imported" % (self.name, obj, value))
|
|
try:
|
|
if issubclass(value, self.klass):
|
|
return value
|
|
except:
|
|
pass
|
|
|
|
self.error(obj, value)
|
|
|
|
def info(self):
|
|
""" Returns a description of the trait."""
|
|
if isinstance(self.klass, six.string_types):
|
|
klass = self.klass
|
|
else:
|
|
klass = self.klass.__module__ + '.' + self.klass.__name__
|
|
result = "a subclass of '%s'" % klass
|
|
if self.allow_none:
|
|
return result + ' or None'
|
|
return result
|
|
|
|
def instance_init(self, obj):
|
|
self._resolve_classes()
|
|
super(Type, self).instance_init(obj)
|
|
|
|
def _resolve_classes(self):
|
|
if isinstance(self.klass, six.string_types):
|
|
self.klass = self._resolve_string(self.klass)
|
|
if isinstance(self.default_value, six.string_types):
|
|
self.default_value = self._resolve_string(self.default_value)
|
|
|
|
def default_value_repr(self):
|
|
value = self.default_value
|
|
if isinstance(value, six.string_types):
|
|
return repr(value)
|
|
else:
|
|
return repr('{}.{}'.format(value.__module__, value.__name__))
|
|
|
|
|
|
class Instance(ClassBasedTraitType):
|
|
"""A trait whose value must be an instance of a specified class.
|
|
|
|
The value can also be an instance of a subclass of the specified class.
|
|
|
|
Subclasses can declare default classes by overriding the klass attribute
|
|
"""
|
|
|
|
klass = None
|
|
|
|
def __init__(self, klass=None, args=None, kw=None, **kwargs):
|
|
"""Construct an Instance trait.
|
|
|
|
This trait allows values that are instances of a particular
|
|
class or its subclasses. Our implementation is quite different
|
|
from that of enthough.traits as we don't allow instances to be used
|
|
for klass and we handle the ``args`` and ``kw`` arguments differently.
|
|
|
|
Parameters
|
|
----------
|
|
klass : class, str
|
|
The class that forms the basis for the trait. Class names
|
|
can also be specified as strings, like 'foo.bar.Bar'.
|
|
args : tuple
|
|
Positional arguments for generating the default value.
|
|
kw : dict
|
|
Keyword arguments for generating the default value.
|
|
allow_none : bool [ default False ]
|
|
Indicates whether None is allowed as a value.
|
|
|
|
Notes
|
|
-----
|
|
If both ``args`` and ``kw`` are None, then the default value is None.
|
|
If ``args`` is a tuple and ``kw`` is a dict, then the default is
|
|
created as ``klass(*args, **kw)``. If exactly one of ``args`` or ``kw`` is
|
|
None, the None is replaced by ``()`` or ``{}``, respectively.
|
|
"""
|
|
if klass is None:
|
|
klass = self.klass
|
|
|
|
if (klass is not None) and (inspect.isclass(klass) or isinstance(klass, six.string_types)):
|
|
self.klass = klass
|
|
else:
|
|
raise TraitError('The klass attribute must be a class'
|
|
' not: %r' % klass)
|
|
|
|
if (kw is not None) and not isinstance(kw, dict):
|
|
raise TraitError("The 'kw' argument must be a dict or None.")
|
|
if (args is not None) and not isinstance(args, tuple):
|
|
raise TraitError("The 'args' argument must be a tuple or None.")
|
|
|
|
self.default_args = args
|
|
self.default_kwargs = kw
|
|
|
|
super(Instance, self).__init__(**kwargs)
|
|
|
|
def validate(self, obj, value):
|
|
if isinstance(value, self.klass):
|
|
return value
|
|
else:
|
|
self.error(obj, value)
|
|
|
|
def info(self):
|
|
if isinstance(self.klass, six.string_types):
|
|
klass = self.klass
|
|
else:
|
|
klass = self.klass.__name__
|
|
result = class_of(klass)
|
|
if self.allow_none:
|
|
return result + ' or None'
|
|
|
|
return result
|
|
|
|
def instance_init(self, obj):
|
|
self._resolve_classes()
|
|
super(Instance, self).instance_init(obj)
|
|
|
|
def _resolve_classes(self):
|
|
if isinstance(self.klass, six.string_types):
|
|
self.klass = self._resolve_string(self.klass)
|
|
|
|
def make_dynamic_default(self):
|
|
if (self.default_args is None) and (self.default_kwargs is None):
|
|
return None
|
|
return self.klass(*(self.default_args or ()),
|
|
**(self.default_kwargs or {}))
|
|
|
|
def default_value_repr(self):
|
|
return repr(self.make_dynamic_default())
|
|
|
|
|
|
class ForwardDeclaredMixin(object):
|
|
"""
|
|
Mixin for forward-declared versions of Instance and Type.
|
|
"""
|
|
def _resolve_string(self, string):
|
|
"""
|
|
Find the specified class name by looking for it in the module in which
|
|
our this_class attribute was defined.
|
|
"""
|
|
modname = self.this_class.__module__
|
|
return import_item('.'.join([modname, string]))
|
|
|
|
|
|
class ForwardDeclaredType(ForwardDeclaredMixin, Type):
|
|
"""
|
|
Forward-declared version of Type.
|
|
"""
|
|
pass
|
|
|
|
|
|
class ForwardDeclaredInstance(ForwardDeclaredMixin, Instance):
|
|
"""
|
|
Forward-declared version of Instance.
|
|
"""
|
|
pass
|
|
|
|
|
|
class This(ClassBasedTraitType):
|
|
"""A trait for instances of the class containing this trait.
|
|
|
|
Because how how and when class bodies are executed, the ``This``
|
|
trait can only have a default value of None. This, and because we
|
|
always validate default values, ``allow_none`` is *always* true.
|
|
"""
|
|
|
|
info_text = 'an instance of the same type as the receiver or None'
|
|
|
|
def __init__(self, **kwargs):
|
|
super(This, self).__init__(None, **kwargs)
|
|
|
|
def validate(self, obj, value):
|
|
# What if value is a superclass of obj.__class__? This is
|
|
# complicated if it was the superclass that defined the This
|
|
# trait.
|
|
if isinstance(value, self.this_class) or (value is None):
|
|
return value
|
|
else:
|
|
self.error(obj, value)
|
|
|
|
|
|
class Union(TraitType):
|
|
"""A trait type representing a Union type."""
|
|
|
|
def __init__(self, trait_types, **kwargs):
|
|
"""Construct a Union trait.
|
|
|
|
This trait allows values that are allowed by at least one of the
|
|
specified trait types. A Union traitlet cannot have metadata on
|
|
its own, besides the metadata of the listed types.
|
|
|
|
Parameters
|
|
----------
|
|
trait_types: sequence
|
|
The list of trait types of length at least 1.
|
|
|
|
Notes
|
|
-----
|
|
Union([Float(), Bool(), Int()]) attempts to validate the provided values
|
|
with the validation function of Float, then Bool, and finally Int.
|
|
"""
|
|
self.trait_types = trait_types
|
|
self.info_text = " or ".join([tt.info() for tt in self.trait_types])
|
|
super(Union, self).__init__(**kwargs)
|
|
|
|
def class_init(self, cls, name):
|
|
for trait_type in self.trait_types:
|
|
trait_type.class_init(cls, None)
|
|
super(Union, self).class_init(cls, name)
|
|
|
|
def instance_init(self, obj):
|
|
for trait_type in self.trait_types:
|
|
trait_type.instance_init(obj)
|
|
super(Union, self).instance_init(obj)
|
|
|
|
def validate(self, obj, value):
|
|
with obj.cross_validation_lock:
|
|
for trait_type in self.trait_types:
|
|
try:
|
|
v = trait_type._validate(obj, value)
|
|
# In the case of an element trait, the name is None
|
|
if self.name is not None:
|
|
setattr(obj, '_' + self.name + '_metadata', trait_type.metadata)
|
|
return v
|
|
except TraitError:
|
|
continue
|
|
self.error(obj, value)
|
|
|
|
def __or__(self, other):
|
|
if isinstance(other, Union):
|
|
return Union(self.trait_types + other.trait_types)
|
|
else:
|
|
return Union(self.trait_types + [other])
|
|
|
|
def make_dynamic_default(self):
|
|
if self.default_value is not Undefined:
|
|
return self.default_value
|
|
for trait_type in self.trait_types:
|
|
if trait_type.default_value is not Undefined:
|
|
return trait_type.default_value
|
|
elif hasattr(trait_type, 'make_dynamic_default'):
|
|
return trait_type.make_dynamic_default()
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Basic TraitTypes implementations/subclasses
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
class Any(TraitType):
|
|
"""A trait which allows any value."""
|
|
default_value = None
|
|
info_text = 'any value'
|
|
|
|
|
|
def _validate_bounds(trait, obj, value):
|
|
"""
|
|
Validate that a number to be applied to a trait is between bounds.
|
|
|
|
If value is not between min_bound and max_bound, this raises a
|
|
TraitError with an error message appropriate for this trait.
|
|
"""
|
|
if trait.min is not None and value < trait.min:
|
|
raise TraitError(
|
|
"The value of the '{name}' trait of {klass} instance should "
|
|
"not be less than {min_bound}, but a value of {value} was "
|
|
"specified".format(
|
|
name=trait.name, klass=class_of(obj),
|
|
value=value, min_bound=trait.min))
|
|
if trait.max is not None and value > trait.max:
|
|
raise TraitError(
|
|
"The value of the '{name}' trait of {klass} instance should "
|
|
"not be greater than {max_bound}, but a value of {value} was "
|
|
"specified".format(
|
|
name=trait.name, klass=class_of(obj),
|
|
value=value, max_bound=trait.max))
|
|
return value
|
|
|
|
|
|
class Int(TraitType):
|
|
"""An int trait."""
|
|
|
|
default_value = 0
|
|
info_text = 'an int'
|
|
|
|
def __init__(self, default_value=Undefined, allow_none=False, **kwargs):
|
|
self.min = kwargs.pop('min', None)
|
|
self.max = kwargs.pop('max', None)
|
|
super(Int, self).__init__(default_value=default_value,
|
|
allow_none=allow_none, **kwargs)
|
|
|
|
def validate(self, obj, value):
|
|
if not isinstance(value, int):
|
|
self.error(obj, value)
|
|
return _validate_bounds(self, obj, value)
|
|
|
|
|
|
class CInt(Int):
|
|
"""A casting version of the int trait."""
|
|
|
|
def validate(self, obj, value):
|
|
try:
|
|
value = int(value)
|
|
except:
|
|
self.error(obj, value)
|
|
return _validate_bounds(self, obj, value)
|
|
|
|
|
|
if six.PY2:
|
|
class Long(TraitType):
|
|
"""A long integer trait."""
|
|
|
|
default_value = 0
|
|
info_text = 'a long'
|
|
|
|
def __init__(self, default_value=Undefined, allow_none=False, **kwargs):
|
|
self.min = kwargs.pop('min', None)
|
|
self.max = kwargs.pop('max', None)
|
|
super(Long, self).__init__(
|
|
default_value=default_value,
|
|
allow_none=allow_none, **kwargs)
|
|
|
|
def _validate_long(self, obj, value):
|
|
if isinstance(value, long):
|
|
return value
|
|
if isinstance(value, int):
|
|
return long(value)
|
|
self.error(obj, value)
|
|
|
|
def validate(self, obj, value):
|
|
value = self._validate_long(obj, value)
|
|
return _validate_bounds(self, obj, value)
|
|
|
|
|
|
class CLong(Long):
|
|
"""A casting version of the long integer trait."""
|
|
|
|
def validate(self, obj, value):
|
|
try:
|
|
value = long(value)
|
|
except:
|
|
self.error(obj, value)
|
|
return _validate_bounds(self, obj, value)
|
|
|
|
|
|
class Integer(TraitType):
|
|
"""An integer trait.
|
|
|
|
Longs that are unnecessary (<= sys.maxint) are cast to ints."""
|
|
|
|
default_value = 0
|
|
info_text = 'an integer'
|
|
|
|
def __init__(self, default_value=Undefined, allow_none=False, **kwargs):
|
|
self.min = kwargs.pop('min', None)
|
|
self.max = kwargs.pop('max', None)
|
|
super(Integer, self).__init__(
|
|
default_value=default_value,
|
|
allow_none=allow_none, **kwargs)
|
|
|
|
def _validate_int(self, obj, value):
|
|
if isinstance(value, int):
|
|
return value
|
|
if isinstance(value, long):
|
|
# downcast longs that fit in int:
|
|
# note that int(n > sys.maxint) returns a long, so
|
|
# we don't need a condition on this cast
|
|
return int(value)
|
|
if sys.platform == "cli":
|
|
from System import Int64
|
|
if isinstance(value, Int64):
|
|
return int(value)
|
|
self.error(obj, value)
|
|
|
|
def validate(self, obj, value):
|
|
value = self._validate_int(obj, value)
|
|
return _validate_bounds(self, obj, value)
|
|
|
|
else:
|
|
Long, CLong = Int, CInt
|
|
Integer = Int
|
|
|
|
|
|
class Float(TraitType):
|
|
"""A float trait."""
|
|
|
|
default_value = 0.0
|
|
info_text = 'a float'
|
|
|
|
def __init__(self, default_value=Undefined, allow_none=False, **kwargs):
|
|
self.min = kwargs.pop('min', -float('inf'))
|
|
self.max = kwargs.pop('max', float('inf'))
|
|
super(Float, self).__init__(default_value=default_value,
|
|
allow_none=allow_none, **kwargs)
|
|
|
|
def validate(self, obj, value):
|
|
if isinstance(value, int):
|
|
value = float(value)
|
|
if not isinstance(value, float):
|
|
self.error(obj, value)
|
|
return _validate_bounds(self, obj, value)
|
|
|
|
|
|
class CFloat(Float):
|
|
"""A casting version of the float trait."""
|
|
|
|
def validate(self, obj, value):
|
|
try:
|
|
value = float(value)
|
|
except:
|
|
self.error(obj, value)
|
|
return _validate_bounds(self, obj, value)
|
|
|
|
|
|
class Complex(TraitType):
|
|
"""A trait for complex numbers."""
|
|
|
|
default_value = 0.0 + 0.0j
|
|
info_text = 'a complex number'
|
|
|
|
def validate(self, obj, value):
|
|
if isinstance(value, complex):
|
|
return value
|
|
if isinstance(value, (float, int)):
|
|
return complex(value)
|
|
self.error(obj, value)
|
|
|
|
|
|
class CComplex(Complex):
|
|
"""A casting version of the complex number trait."""
|
|
|
|
def validate (self, obj, value):
|
|
try:
|
|
return complex(value)
|
|
except:
|
|
self.error(obj, value)
|
|
|
|
# We should always be explicit about whether we're using bytes or unicode, both
|
|
# for Python 3 conversion and for reliable unicode behaviour on Python 2. So
|
|
# we don't have a Str type.
|
|
class Bytes(TraitType):
|
|
"""A trait for byte strings."""
|
|
|
|
default_value = b''
|
|
info_text = 'a bytes object'
|
|
|
|
def validate(self, obj, value):
|
|
if isinstance(value, bytes):
|
|
return value
|
|
self.error(obj, value)
|
|
|
|
|
|
class CBytes(Bytes):
|
|
"""A casting version of the byte string trait."""
|
|
|
|
def validate(self, obj, value):
|
|
try:
|
|
return bytes(value)
|
|
except:
|
|
self.error(obj, value)
|
|
|
|
|
|
class Unicode(TraitType):
|
|
"""A trait for unicode strings."""
|
|
|
|
default_value = u''
|
|
info_text = 'a unicode string'
|
|
|
|
def validate(self, obj, value):
|
|
if isinstance(value, six.text_type):
|
|
return value
|
|
if isinstance(value, bytes):
|
|
try:
|
|
return value.decode('ascii', 'strict')
|
|
except UnicodeDecodeError:
|
|
msg = "Could not decode {!r} for unicode trait '{}' of {} instance."
|
|
raise TraitError(msg.format(value, self.name, class_of(obj)))
|
|
self.error(obj, value)
|
|
|
|
|
|
class CUnicode(Unicode):
|
|
"""A casting version of the unicode trait."""
|
|
|
|
def validate(self, obj, value):
|
|
try:
|
|
return six.text_type(value)
|
|
except:
|
|
self.error(obj, value)
|
|
|
|
|
|
class ObjectName(TraitType):
|
|
"""A string holding a valid object name in this version of Python.
|
|
|
|
This does not check that the name exists in any scope."""
|
|
info_text = "a valid object identifier in Python"
|
|
|
|
if six.PY2:
|
|
# Python 2:
|
|
def coerce_str(self, obj, value):
|
|
"In Python 2, coerce ascii-only unicode to str"
|
|
if isinstance(value, unicode):
|
|
try:
|
|
return str(value)
|
|
except UnicodeEncodeError:
|
|
self.error(obj, value)
|
|
return value
|
|
else:
|
|
coerce_str = staticmethod(lambda _,s: s)
|
|
|
|
def validate(self, obj, value):
|
|
value = self.coerce_str(obj, value)
|
|
|
|
if isinstance(value, six.string_types) and isidentifier(value):
|
|
return value
|
|
self.error(obj, value)
|
|
|
|
class DottedObjectName(ObjectName):
|
|
"""A string holding a valid dotted object name in Python, such as A.b3._c"""
|
|
def validate(self, obj, value):
|
|
value = self.coerce_str(obj, value)
|
|
|
|
if isinstance(value, six.string_types) and all(isidentifier(a)
|
|
for a in value.split('.')):
|
|
return value
|
|
self.error(obj, value)
|
|
|
|
|
|
class Bool(TraitType):
|
|
"""A boolean (True, False) trait."""
|
|
|
|
default_value = False
|
|
info_text = 'a boolean'
|
|
|
|
def validate(self, obj, value):
|
|
if isinstance(value, bool):
|
|
return value
|
|
self.error(obj, value)
|
|
|
|
|
|
class CBool(Bool):
|
|
"""A casting version of the boolean trait."""
|
|
|
|
def validate(self, obj, value):
|
|
try:
|
|
return bool(value)
|
|
except:
|
|
self.error(obj, value)
|
|
|
|
|
|
class Enum(TraitType):
|
|
"""An enum whose value must be in a given sequence."""
|
|
|
|
def __init__(self, values, default_value=Undefined, **kwargs):
|
|
self.values = values
|
|
if kwargs.get('allow_none', False) and default_value is Undefined:
|
|
default_value = None
|
|
super(Enum, self).__init__(default_value, **kwargs)
|
|
|
|
def validate(self, obj, value):
|
|
if value in self.values:
|
|
return value
|
|
self.error(obj, value)
|
|
|
|
def info(self):
|
|
""" Returns a description of the trait."""
|
|
result = 'any of ' + repr(self.values)
|
|
if self.allow_none:
|
|
return result + ' or None'
|
|
return result
|
|
|
|
class CaselessStrEnum(Enum):
|
|
"""An enum of strings where the case should be ignored."""
|
|
|
|
def __init__(self, values, default_value=Undefined, **kwargs):
|
|
values = [cast_unicode_py2(value) for value in values]
|
|
super(CaselessStrEnum, self).__init__(values, default_value=default_value, **kwargs)
|
|
|
|
def validate(self, obj, value):
|
|
if isinstance(value, str):
|
|
value = cast_unicode_py2(value)
|
|
if not isinstance(value, six.string_types):
|
|
self.error(obj, value)
|
|
|
|
for v in self.values:
|
|
if v.lower() == value.lower():
|
|
return v
|
|
self.error(obj, value)
|
|
|
|
class Container(Instance):
|
|
"""An instance of a container (list, set, etc.)
|
|
|
|
To be subclassed by overriding klass.
|
|
"""
|
|
klass = None
|
|
_cast_types = ()
|
|
_valid_defaults = SequenceTypes
|
|
_trait = None
|
|
|
|
def __init__(self, trait=None, default_value=None, **kwargs):
|
|
"""Create a container trait type from a list, set, or tuple.
|
|
|
|
The default value is created by doing ``List(default_value)``,
|
|
which creates a copy of the ``default_value``.
|
|
|
|
``trait`` can be specified, which restricts the type of elements
|
|
in the container to that TraitType.
|
|
|
|
If only one arg is given and it is not a Trait, it is taken as
|
|
``default_value``:
|
|
|
|
``c = List([1, 2, 3])``
|
|
|
|
Parameters
|
|
----------
|
|
|
|
trait : TraitType [ optional ]
|
|
the type for restricting the contents of the Container. If unspecified,
|
|
types are not checked.
|
|
|
|
default_value : SequenceType [ optional ]
|
|
The default value for the Trait. Must be list/tuple/set, and
|
|
will be cast to the container type.
|
|
|
|
allow_none : bool [ default False ]
|
|
Whether to allow the value to be None
|
|
|
|
**kwargs : any
|
|
further keys for extensions to the Trait (e.g. config)
|
|
|
|
"""
|
|
# allow List([values]):
|
|
if default_value is None and not is_trait(trait):
|
|
default_value = trait
|
|
trait = None
|
|
|
|
if default_value is None:
|
|
args = ()
|
|
elif isinstance(default_value, self._valid_defaults):
|
|
args = (default_value,)
|
|
else:
|
|
raise TypeError('default value of %s was %s' %(self.__class__.__name__, default_value))
|
|
|
|
if is_trait(trait):
|
|
if isinstance(trait, type):
|
|
warn("Traits should be given as instances, not types (for example, `Int()`, not `Int`)."
|
|
" Passing types is deprecated in traitlets 4.1.",
|
|
DeprecationWarning, stacklevel=3)
|
|
self._trait = trait() if isinstance(trait, type) else trait
|
|
elif trait is not None:
|
|
raise TypeError("`trait` must be a Trait or None, got %s" % repr_type(trait))
|
|
|
|
super(Container,self).__init__(klass=self.klass, args=args, **kwargs)
|
|
|
|
def element_error(self, obj, element, validator):
|
|
e = "Element of the '%s' trait of %s instance must be %s, but a value of %s was specified." \
|
|
% (self.name, class_of(obj), validator.info(), repr_type(element))
|
|
raise TraitError(e)
|
|
|
|
def validate(self, obj, value):
|
|
if isinstance(value, self._cast_types):
|
|
value = self.klass(value)
|
|
value = super(Container, self).validate(obj, value)
|
|
if value is None:
|
|
return value
|
|
|
|
value = self.validate_elements(obj, value)
|
|
|
|
return value
|
|
|
|
def validate_elements(self, obj, value):
|
|
validated = []
|
|
if self._trait is None or isinstance(self._trait, Any):
|
|
return value
|
|
for v in value:
|
|
try:
|
|
v = self._trait._validate(obj, v)
|
|
except TraitError:
|
|
self.element_error(obj, v, self._trait)
|
|
else:
|
|
validated.append(v)
|
|
return self.klass(validated)
|
|
|
|
def class_init(self, cls, name):
|
|
if isinstance(self._trait, TraitType):
|
|
self._trait.class_init(cls, None)
|
|
super(Container, self).class_init(cls, name)
|
|
|
|
def instance_init(self, obj):
|
|
if isinstance(self._trait, TraitType):
|
|
self._trait.instance_init(obj)
|
|
super(Container, self).instance_init(obj)
|
|
|
|
|
|
class List(Container):
|
|
"""An instance of a Python list."""
|
|
klass = list
|
|
_cast_types = (tuple,)
|
|
|
|
def __init__(self, trait=None, default_value=None, minlen=0, maxlen=sys.maxsize, **kwargs):
|
|
"""Create a List trait type from a list, set, or tuple.
|
|
|
|
The default value is created by doing ``list(default_value)``,
|
|
which creates a copy of the ``default_value``.
|
|
|
|
``trait`` can be specified, which restricts the type of elements
|
|
in the container to that TraitType.
|
|
|
|
If only one arg is given and it is not a Trait, it is taken as
|
|
``default_value``:
|
|
|
|
``c = List([1, 2, 3])``
|
|
|
|
Parameters
|
|
----------
|
|
|
|
trait : TraitType [ optional ]
|
|
the type for restricting the contents of the Container.
|
|
If unspecified, types are not checked.
|
|
|
|
default_value : SequenceType [ optional ]
|
|
The default value for the Trait. Must be list/tuple/set, and
|
|
will be cast to the container type.
|
|
|
|
minlen : Int [ default 0 ]
|
|
The minimum length of the input list
|
|
|
|
maxlen : Int [ default sys.maxsize ]
|
|
The maximum length of the input list
|
|
"""
|
|
self._minlen = minlen
|
|
self._maxlen = maxlen
|
|
super(List, self).__init__(trait=trait, default_value=default_value,
|
|
**kwargs)
|
|
|
|
def length_error(self, obj, value):
|
|
e = "The '%s' trait of %s instance must be of length %i <= L <= %i, but a value of %s was specified." \
|
|
% (self.name, class_of(obj), self._minlen, self._maxlen, value)
|
|
raise TraitError(e)
|
|
|
|
def validate_elements(self, obj, value):
|
|
length = len(value)
|
|
if length < self._minlen or length > self._maxlen:
|
|
self.length_error(obj, value)
|
|
|
|
return super(List, self).validate_elements(obj, value)
|
|
|
|
def validate(self, obj, value):
|
|
value = super(List, self).validate(obj, value)
|
|
value = self.validate_elements(obj, value)
|
|
return value
|
|
|
|
|
|
class Set(List):
|
|
"""An instance of a Python set."""
|
|
klass = set
|
|
_cast_types = (tuple, list)
|
|
|
|
# Redefine __init__ just to make the docstring more accurate.
|
|
def __init__(self, trait=None, default_value=None, minlen=0, maxlen=sys.maxsize,
|
|
**kwargs):
|
|
"""Create a Set trait type from a list, set, or tuple.
|
|
|
|
The default value is created by doing ``set(default_value)``,
|
|
which creates a copy of the ``default_value``.
|
|
|
|
``trait`` can be specified, which restricts the type of elements
|
|
in the container to that TraitType.
|
|
|
|
If only one arg is given and it is not a Trait, it is taken as
|
|
``default_value``:
|
|
|
|
``c = Set({1, 2, 3})``
|
|
|
|
Parameters
|
|
----------
|
|
|
|
trait : TraitType [ optional ]
|
|
the type for restricting the contents of the Container.
|
|
If unspecified, types are not checked.
|
|
|
|
default_value : SequenceType [ optional ]
|
|
The default value for the Trait. Must be list/tuple/set, and
|
|
will be cast to the container type.
|
|
|
|
minlen : Int [ default 0 ]
|
|
The minimum length of the input list
|
|
|
|
maxlen : Int [ default sys.maxsize ]
|
|
The maximum length of the input list
|
|
"""
|
|
super(Set, self).__init__(trait, default_value, minlen, maxlen, **kwargs)
|
|
|
|
|
|
class Tuple(Container):
|
|
"""An instance of a Python tuple."""
|
|
klass = tuple
|
|
_cast_types = (list,)
|
|
|
|
def __init__(self, *traits, **kwargs):
|
|
"""Create a tuple from a list, set, or tuple.
|
|
|
|
Create a fixed-type tuple with Traits:
|
|
|
|
``t = Tuple(Int(), Str(), CStr())``
|
|
|
|
would be length 3, with Int,Str,CStr for each element.
|
|
|
|
If only one arg is given and it is not a Trait, it is taken as
|
|
default_value:
|
|
|
|
``t = Tuple((1, 2, 3))``
|
|
|
|
Otherwise, ``default_value`` *must* be specified by keyword.
|
|
|
|
Parameters
|
|
----------
|
|
|
|
`*traits` : TraitTypes [ optional ]
|
|
the types for restricting the contents of the Tuple. If unspecified,
|
|
types are not checked. If specified, then each positional argument
|
|
corresponds to an element of the tuple. Tuples defined with traits
|
|
are of fixed length.
|
|
|
|
default_value : SequenceType [ optional ]
|
|
The default value for the Tuple. Must be list/tuple/set, and
|
|
will be cast to a tuple. If ``traits`` are specified,
|
|
``default_value`` must conform to the shape and type they specify.
|
|
"""
|
|
default_value = kwargs.pop('default_value', Undefined)
|
|
# allow Tuple((values,)):
|
|
if len(traits) == 1 and default_value is Undefined and not is_trait(traits[0]):
|
|
default_value = traits[0]
|
|
traits = ()
|
|
|
|
if default_value is Undefined:
|
|
args = ()
|
|
elif isinstance(default_value, self._valid_defaults):
|
|
args = (default_value,)
|
|
else:
|
|
raise TypeError('default value of %s was %s' %(self.__class__.__name__, default_value))
|
|
|
|
self._traits = []
|
|
for trait in traits:
|
|
if isinstance(trait, type):
|
|
warn("Traits should be given as instances, not types (for example, `Int()`, not `Int`)"
|
|
" Passing types is deprecated in traitlets 4.1.",
|
|
DeprecationWarning, stacklevel=2)
|
|
t = trait() if isinstance(trait, type) else trait
|
|
self._traits.append(t)
|
|
|
|
if self._traits and default_value is None:
|
|
# don't allow default to be an empty container if length is specified
|
|
args = None
|
|
super(Container,self).__init__(klass=self.klass, args=args, **kwargs)
|
|
|
|
def validate_elements(self, obj, value):
|
|
if not self._traits:
|
|
# nothing to validate
|
|
return value
|
|
if len(value) != len(self._traits):
|
|
e = "The '%s' trait of %s instance requires %i elements, but a value of %s was specified." \
|
|
% (self.name, class_of(obj), len(self._traits), repr_type(value))
|
|
raise TraitError(e)
|
|
|
|
validated = []
|
|
for t, v in zip(self._traits, value):
|
|
try:
|
|
v = t._validate(obj, v)
|
|
except TraitError:
|
|
self.element_error(obj, v, t)
|
|
else:
|
|
validated.append(v)
|
|
return tuple(validated)
|
|
|
|
def class_init(self, cls, name):
|
|
for trait in self._traits:
|
|
if isinstance(trait, TraitType):
|
|
trait.class_init(cls, None)
|
|
super(Container, self).class_init(cls, name)
|
|
|
|
def instance_init(self, obj):
|
|
for trait in self._traits:
|
|
if isinstance(trait, TraitType):
|
|
trait.instance_init(obj)
|
|
super(Container, self).instance_init(obj)
|
|
|
|
|
|
class Dict(Instance):
|
|
"""An instance of a Python dict."""
|
|
_trait = None
|
|
|
|
def __init__(self, trait=None, traits=None, default_value=Undefined,
|
|
**kwargs):
|
|
"""Create a dict trait type from a Python dict.
|
|
|
|
The default value is created by doing ``dict(default_value)``,
|
|
which creates a copy of the ``default_value``.
|
|
|
|
Parameters
|
|
----------
|
|
|
|
trait : TraitType [ optional ]
|
|
The specified trait type to check and use to restrict contents of
|
|
the Container. If unspecified, trait types are not checked.
|
|
|
|
traits : Dictionary of trait types [ optional ]
|
|
A Python dictionary containing the types that are valid for
|
|
restricting the content of the Dict Container for certain keys.
|
|
|
|
default_value : SequenceType [ optional ]
|
|
The default value for the Dict. Must be dict, tuple, or None, and
|
|
will be cast to a dict if not None. If `trait` is specified, the
|
|
`default_value` must conform to the constraints it specifies.
|
|
"""
|
|
# Handling positional arguments
|
|
if default_value is Undefined and trait is not None:
|
|
if not is_trait(trait):
|
|
default_value = trait
|
|
trait = None
|
|
|
|
# Handling default value
|
|
if default_value is Undefined:
|
|
default_value = {}
|
|
if default_value is None:
|
|
args = None
|
|
elif isinstance(default_value, dict):
|
|
args = (default_value,)
|
|
elif isinstance(default_value, SequenceTypes):
|
|
args = (default_value,)
|
|
else:
|
|
raise TypeError('default value of Dict was %s' % default_value)
|
|
|
|
# Case where a type of TraitType is provided rather than an instance
|
|
if is_trait(trait):
|
|
if isinstance(trait, type):
|
|
warn("Traits should be given as instances, not types (for example, `Int()`, not `Int`)"
|
|
" Passing types is deprecated in traitlets 4.1.",
|
|
DeprecationWarning, stacklevel=2)
|
|
self._trait = trait() if isinstance(trait, type) else trait
|
|
elif trait is not None:
|
|
raise TypeError("`trait` must be a Trait or None, got %s" % repr_type(trait))
|
|
|
|
self._traits = traits
|
|
|
|
super(Dict, self).__init__(klass=dict, args=args, **kwargs)
|
|
|
|
def element_error(self, obj, element, validator):
|
|
e = "Element of the '%s' trait of %s instance must be %s, but a value of %s was specified." \
|
|
% (self.name, class_of(obj), validator.info(), repr_type(element))
|
|
raise TraitError(e)
|
|
|
|
def validate(self, obj, value):
|
|
value = super(Dict, self).validate(obj, value)
|
|
if value is None:
|
|
return value
|
|
value = self.validate_elements(obj, value)
|
|
return value
|
|
|
|
def validate_elements(self, obj, value):
|
|
use_dict = bool(self._traits)
|
|
default_to = (self._trait or Any())
|
|
if not use_dict and isinstance(default_to, Any):
|
|
return value
|
|
|
|
validated = {}
|
|
for key in value:
|
|
if use_dict and key in self._traits:
|
|
validate_with = self._traits[key]
|
|
else:
|
|
validate_with = default_to
|
|
try:
|
|
v = value[key]
|
|
if not isinstance(validate_with, Any):
|
|
v = validate_with._validate(obj, v)
|
|
except TraitError:
|
|
self.element_error(obj, v, validate_with)
|
|
else:
|
|
validated[key] = v
|
|
|
|
return self.klass(validated)
|
|
|
|
def class_init(self, cls, name):
|
|
if isinstance(self._trait, TraitType):
|
|
self._trait.class_init(cls, None)
|
|
if self._traits is not None:
|
|
for trait in self._traits.values():
|
|
trait.class_init(cls, None)
|
|
super(Dict, self).class_init(cls, name)
|
|
|
|
def instance_init(self, obj):
|
|
if isinstance(self._trait, TraitType):
|
|
self._trait.instance_init(obj)
|
|
if self._traits is not None:
|
|
for trait in self._traits.values():
|
|
trait.instance_init(obj)
|
|
super(Dict, self).instance_init(obj)
|
|
|
|
|
|
class TCPAddress(TraitType):
|
|
"""A trait for an (ip, port) tuple.
|
|
|
|
This allows for both IPv4 IP addresses as well as hostnames.
|
|
"""
|
|
|
|
default_value = ('127.0.0.1', 0)
|
|
info_text = 'an (ip, port) tuple'
|
|
|
|
def validate(self, obj, value):
|
|
if isinstance(value, tuple):
|
|
if len(value) == 2:
|
|
if isinstance(value[0], six.string_types) and isinstance(value[1], int):
|
|
port = value[1]
|
|
if port >= 0 and port <= 65535:
|
|
return value
|
|
self.error(obj, value)
|
|
|
|
class CRegExp(TraitType):
|
|
"""A casting compiled regular expression trait.
|
|
|
|
Accepts both strings and compiled regular expressions. The resulting
|
|
attribute will be a compiled regular expression."""
|
|
|
|
info_text = 'a regular expression'
|
|
|
|
def validate(self, obj, value):
|
|
try:
|
|
return re.compile(value)
|
|
except:
|
|
self.error(obj, value)
|
|
|
|
|
|
class UseEnum(TraitType):
|
|
"""Use a Enum class as model for the data type description.
|
|
Note that if no default-value is provided, the first enum-value is used
|
|
as default-value.
|
|
|
|
.. sourcecode:: python
|
|
|
|
# -- SINCE: Python 3.4 (or install backport: pip install enum34)
|
|
import enum
|
|
from traitlets import HasTraits, UseEnum
|
|
|
|
class Color(enum.Enum):
|
|
red = 1 # -- IMPLICIT: default_value
|
|
blue = 2
|
|
green = 3
|
|
|
|
class MyEntity(HasTraits):
|
|
color = UseEnum(Color, default_value=Color.blue)
|
|
|
|
entity = MyEntity(color=Color.red)
|
|
entity.color = Color.green # USE: Enum-value (preferred)
|
|
entity.color = "green" # USE: name (as string)
|
|
entity.color = "Color.green" # USE: scoped-name (as string)
|
|
entity.color = 3 # USE: number (as int)
|
|
assert entity.color is Color.green
|
|
"""
|
|
default_value = None
|
|
info_text = "Trait type adapter to a Enum class"
|
|
|
|
def __init__(self, enum_class, default_value=None, **kwargs):
|
|
assert issubclass(enum_class, enum.Enum), \
|
|
"REQUIRE: enum.Enum, but was: %r" % enum_class
|
|
allow_none = kwargs.get("allow_none", False)
|
|
if default_value is None and not allow_none:
|
|
default_value = list(enum_class.__members__.values())[0]
|
|
super(UseEnum, self).__init__(default_value=default_value, **kwargs)
|
|
self.enum_class = enum_class
|
|
self.name_prefix = enum_class.__name__ + "."
|
|
|
|
def select_by_number(self, value, default=Undefined):
|
|
"""Selects enum-value by using its number-constant."""
|
|
assert isinstance(value, int)
|
|
enum_members = self.enum_class.__members__
|
|
for enum_item in enum_members.values():
|
|
if enum_item.value == value:
|
|
return enum_item
|
|
# -- NOT FOUND:
|
|
return default
|
|
|
|
def select_by_name(self, value, default=Undefined):
|
|
"""Selects enum-value by using its name or scoped-name."""
|
|
assert isinstance(value, six.string_types)
|
|
if value.startswith(self.name_prefix):
|
|
# -- SUPPORT SCOPED-NAMES, like: "Color.red" => "red"
|
|
value = value.replace(self.name_prefix, "", 1)
|
|
return self.enum_class.__members__.get(value, default)
|
|
|
|
def validate(self, obj, value):
|
|
if isinstance(value, self.enum_class):
|
|
return value
|
|
elif isinstance(value, int):
|
|
# -- CONVERT: number => enum_value (item)
|
|
value2 = self.select_by_number(value)
|
|
if value2 is not Undefined:
|
|
return value2
|
|
elif isinstance(value, six.string_types):
|
|
# -- CONVERT: name or scoped_name (as string) => enum_value (item)
|
|
value2 = self.select_by_name(value)
|
|
if value2 is not Undefined:
|
|
return value2
|
|
elif value is None:
|
|
if self.allow_none:
|
|
return None
|
|
else:
|
|
return self.default_value
|
|
self.error(obj, value)
|
|
|
|
def info(self):
|
|
"""Returns a description of this Enum trait (in case of errors)."""
|
|
result = "Any of: %s" % ", ".join(self.enum_class.__members__.keys())
|
|
if self.allow_none:
|
|
return result + " or None"
|
|
return result
|