def test_subclasses_weakref(self):
""" Make sure that dynamically created subclasses are not held
strongly by HasTraits.
"""
previous_subclasses = HasTraits.__subclasses__()
_create_subclass()
_create_subclass()
_create_subclass()
_create_subclass()
gc.collect()
self.assertEqual(previous_subclasses, HasTraits.__subclasses__())
def test_subclasses_weakref(self):
""" Make sure that dynamically created subclasses are not held
strongly by HasTraits.
"""
previous_subclasses = HasTraits.__subclasses__()
_create_subclass()
_create_subclass()
_create_subclass()
_create_subclass()
gc.collect()
self.assertEqual(previous_subclasses, HasTraits.__subclasses__())
def __init__(self, query_object, **kwargs):
'''
Creates a dialog window for selecting date period, source classes and event severity levels/types.
:param query_object:
:return:
'''
assert isinstance(query_object, EventSelectionQuery)
self.shown_event_names_list = "\n".join(
list(query_object.list_of_event_names))
self.query_object = query_object
self.query_start_date = query_object.period_start_date
self.query_end_date = query_object.period_end_date
HasTraits.__init__(self, **kwargs)
def test_subclasses_weakref(self):
""" Make sure that dynamically created subclasses are not held
strongly by HasTraits.
"""
previous_subclasses = HasTraits.__subclasses__()
_create_subclass()
_create_subclass()
_create_subclass()
_create_subclass()
gc.collect()
# In Python < 3.6, we can end up seeing the same subclasses but in
# a different order, so use assertCountEqual rather than assertEqual.
# Ref: enthought/traits#1282.
self.assertCountEqual(previous_subclasses, HasTraits.__subclasses__())
def test_validate(self):
""" Check the validation method.
"""
foo = Dict()
# invalid value
with self.assertRaises(TraitError):
foo.validate(object=HasTraits(), name="bar", value=None)
# valid value
result = foo.validate(object=HasTraits(), name="bar", value={})
self.assertIsInstance(result, TraitDictObject)
# object is None (check for issue #71)
result = foo.validate(object=None, name="bar", value={})
self.assertEqual(result, {})
def test__trait_set_inited(self):
foo = HasTraits.__new__(HasTraits)
self.assertFalse(foo.traits_inited())
foo._trait_set_inited()
self.assertTrue(foo.traits_inited())
def __init__(self, obj=None, **kw ):
"ClassModel Constructor, accepting the initialization object (or dictionary)"
#--------------------------------------------------------------------------------------------------
HasTraits.__init__(self, **kw)
if self._templates:
self.add_trait( "Templates", Enum( "", self._templates.keys(), private=True, visible=True ) )
if obj is not None:
try:
v = vars(obj)
except TypeError:
#Maybe its aready a dictionary -> not the most intended way
self.set_init( obj ) #we leave this one to raise exception in case element cant be "iterized"
else:
self.set_init( v )
self.__orig_obj = obj
def main():
""" Entry point for standalone testing/debugging. """
from pyanno.modelBt_loopdesign import ModelBtLoopDesign
model = ModelBtLoopDesign.create_initial_state(5)
annotations = model.generate_annotations(2)
anno = AnnotationsContainer.from_array(annotations, name='blah')
model_view = AnnotationsView(annotations_container=anno, model=HasTraits())
model_view.configure_traits()
return model, annotations, model_view
def set_annotations(self, annotations_container):
"""Update window with a new set of annotations."""
self.annotations_view = AnnotationsView(
annotations_container=annotations_container,
nclasses=self.model.nclasses,
application=self.application,
model=HasTraits())
self.annotations_stats_view = AnnotationsStatisticsView(
annotations=self.annotations, nclasses=self.nclasses)
self.annotations_are_defined = True
self.annotations_updated = True
def __init__(self, obj, as_list=False ):
"""Contructor for a generic trait. Accepts an object, used for initialization.
"as_list" flag shall be set to True in case the object is effectivelly a list but shall be
rendered as an object, which is useful for mixed type lists"""
#--------------------------------------------------------------------------------------------------
HasTraits.__init__(self)
self.__is_list = as_list
#Get object properties or generate from list
if as_list:
obj_props = dict( ('pos'+str(i), value) for i, value in enumerate(obj) )
else:
try:
obj_props = vars(obj)
self.__orig_obj = obj
except TypeError:
#Maybe not the most intended way
obj_props = obj
self.__is_dict = True
new_traits = self._create_get_traits( self.add_trait, obj_props )
self.set( **new_traits )
def test_hastraits_deepcopy(self):
# Regression test for enthought/traits#2 and enthought/traits#16
from copy import deepcopy
a = HasTraits()
a.add_trait("foo", Int)
a.foo = 1
with self.assertRaises(TraitError):
a.foo = "a"
copied_a = deepcopy(a)
with self.assertRaises(TraitError):
copied_a.foo = "a"
def test_hastraits_pickle(self):
# Regression test for enthought/traits#2 and enthought/traits#16
from pickle import dumps, loads
a = HasTraits()
a.add_trait("foo", Int)
a.foo = 1
with self.assertRaises(TraitError):
a.foo = "a"
pickled_a = dumps(a)
unpickled_a = loads(pickled_a)
with self.assertRaises(TraitError):
unpickled_a.foo = "a"
def test_traits_inited(self):
foo = HasTraits()
self.assertTrue(foo.traits_inited())
def _annotations_view_default(self):
anno = AnnotationsContainer.from_array([[0]], name='<undefined>')
return AnnotationsView(annotations_container=anno,
nclasses=self.model.nclasses,
application=self.application,
model=HasTraits())
def f():
obj = HasTraits()
obj.on_trait_change(handler)
def f():
obj = HasTraits()
obj.on_trait_change(handler)
