def test_basics(self):
c = Counter('abcaba')
self.assertEqual(c, Counter({'a':3 , 'b': 2, 'c': 1}))
self.assertEqual(c, Counter(a=3, b=2, c=1))
self.assertIsInstance(c, dict)
self.assertIsInstance(c, Mapping)
self.assertTrue(misc_tools.is_subclass(Counter, dict))
self.assertTrue(misc_tools.is_subclass(Counter, Mapping))
self.assertEqual(len(c), 3)
self.assertEqual(sum(c.values()), 6)
self.assertEqual(sorted(c.values()), [1, 2, 3])
self.assertEqual(sorted(c.keys()), ['a', 'b', 'c'])
self.assertEqual(sorted(c), ['a', 'b', 'c'])
self.assertEqual(sorted(c.items()),
[('a', 3), ('b', 2), ('c', 1)])
self.assertEqual(c['b'], 2)
self.assertEqual(c['z'], 0)
self.assertEqual(c.__contains__('c'), True)
self.assertEqual(c.__contains__('z'), False)
self.assertEqual(c.get('b', 10), 2)
self.assertEqual(c.get('z', 10), 10)
self.assertEqual(c, dict(a=3, b=2, c=1))
self.assertEqual(repr(c), "Counter({'a': 3, 'b': 2, 'c': 1})")
self.assertEqual(c.most_common(), [('a', 3), ('b', 2), ('c', 1)])
for i in range(5):
self.assertEqual(c.most_common(i),
[('a', 3), ('b', 2), ('c', 1)][:i])
self.assertEqual(''.join(sorted(c.elements())), 'aaabbc')
c['a'] += 1 # increment an existing value
c['b'] -= 2 # sub existing value to zero
del c['c'] # remove an entry
del c['c'] # make sure that del doesn't raise KeyError
c['d'] -= 2 # sub from a missing value
c['e'] = -5 # directly assign a missing value
c['f'] += 4 # add to a missing value
self.assertEqual(c, dict(a=4, b=0, d=-2, e=-5, f=4))
self.assertEqual(''.join(sorted(c.elements())), 'aaaaffff')
self.assertEqual(c.pop('f'), 4)
self.assertNotIn('f', c)
for i in range(3):
elem, cnt = c.popitem()
self.assertNotIn(elem, c)
c.clear()
self.assertEqual(c, {})
self.assertEqual(repr(c), 'Counter()')
self.assertRaises(NotImplementedError, Counter.fromkeys, 'abc')
self.assertRaises(TypeError, hash, c)
c.update(dict(a=5, b=3))
c.update(c=1)
c.update(Counter('a' * 50 + 'b' * 30))
c.update() # test case with no args
c.__init__('a' * 500 + 'b' * 300)
c.__init__('cdc')
c.__init__()
self.assertEqual(c, dict(a=555, b=333, c=3, d=1))
self.assertEqual(c.setdefault('d', 5), 1)
self.assertEqual(c['d'], 1)
self.assertEqual(c.setdefault('e', 5), 5)
self.assertEqual(c['e'], 5)
def __init_analysis(self):
'''Analyze the simpack.'''
simpack = self.simpack
try:
State = simpack.State
except AttributeError:
raise InvalidSimpack("The `%s` simpack does not define a `State` "
"class." % simpack.__name__.rsplit('.')[-1])
if not misc_tools.is_subclass(State, garlicsim.data_structures.State):
raise InvalidSimpack("The `%s` simpack defines a `State` class, "
"but it's not a subclass of "
"`garlicsim.data_structures.State`." % \
simpack.__name__.rsplit('.')[-1])
state_methods = dict(
(name, value) for (name, value) in
list(misc_tools.getted_vars(State).items()) if isinstance(value, collections.Callable)
)
self.step_functions_by_type = dict((step_type, []) for step_type in
step_types.step_types_list)
'''dict mapping from each step type to step functions of that type.'''
for method in list(state_methods.values()):
step_type = StepType.get_step_type(method)
if step_type:
self.step_functions_by_type[step_type].append(method)
if self.step_functions_by_type[step_types.HistoryStep] or \
self.step_functions_by_type[step_types.HistoryStepGenerator]:
self.history_dependent = True
self.all_step_functions = (
self.step_functions_by_type[step_types.HistoryStepGenerator] +
self.step_functions_by_type[step_types.HistoryStep]
)
if (self.step_functions_by_type[step_types.SimpleStep] or
self.step_functions_by_type[step_types.StepGenerator] or
self.step_functions_by_type[step_types.InplaceStep] or
self.step_functions_by_type[step_types.InplaceStepGenerator]):
raise InvalidSimpack("The `%s` simpack is defining both a "
"history-dependent step and a "
"non-history-dependent step - which "
"is forbidden." % \
simpack.__name__.rsplit('.')[-1])
else: # No history step defined
self.history_dependent = False
self.all_step_functions = (
self.step_functions_by_type[step_types.StepGenerator] + \
self.step_functions_by_type[step_types.SimpleStep] + \
self.step_functions_by_type[step_types.InplaceStepGenerator] +\
self.step_functions_by_type[step_types.InplaceStep]
)
# (no-op assignments, just for docs:)
self.history_dependent = self.history_dependent
'''Flag saying whether the simpack looks at previous states.'''
self.all_step_functions = self.all_step_functions
'''
All the step functions that the simpack provides, sorted by priority.
'''
if not self.all_step_functions:
raise InvalidSimpack("The `%s` simpack has not defined any kind "
"of step function." % \
simpack.__name__.rsplit('.')[-1])
self.default_step_function = self.all_step_functions[0]
'''
def __init_analysis_cruncher_types(self):
'''Figure out which crunchers this simpack can use.'''
# todo: possibly fix `CRUNCHERS` to some canonical state in `.settings`
from garlicsim.asynchronous_crunching import crunchers, BaseCruncher
simpack = self.simpack
self.cruncher_types_availability = OrderedDict()
'''dict mapping from cruncher type to whether it can be used.'''
self.available_cruncher_types = []
'''The cruncher types that this simpack can use.'''
CRUNCHERS = self.settings.CRUNCHERS
if isinstance(CRUNCHERS, str):
(cruncher_type,) = \
[cruncher_type_ for cruncher_type_ in
crunchers.cruncher_types_list if
cruncher_type_.__name__ == CRUNCHERS]
self.available_cruncher_types = [cruncher_type]
self.cruncher_types_availability[cruncher_type] = True
### Giving unavailability reasons: ################################
# #
unavailable_cruncher_types = \
[cruncher_type_ for cruncher_type_ in
crunchers.cruncher_types_list if cruncher_type_ not in
self.available_cruncher_types]
self.cruncher_types_availability.update(dict(
(
unavailable_cruncher_type,
ReasonedBool(
False,
'The `%s` simpack specified `%s` as the only '
'available cruncher type.' % \
(simpack.__name__.rsplit('.')[-1],
cruncher_type.__name__)
)
) for unavailable_cruncher_type in unavailable_cruncher_types
))
# #
###################################################################
elif misc_tools.is_subclass(CRUNCHERS, BaseCruncher):
cruncher_type = CRUNCHERS
self.available_cruncher_types = [cruncher_type]
self.cruncher_types_availability[cruncher_type] = True
### Giving unavailability reasons: ################################
# #
unavailable_cruncher_types = \
[cruncher_type_ for cruncher_type_ in
crunchers.cruncher_types_list if cruncher_type_ not in
self.available_cruncher_types]
self.cruncher_types_availability.update(dict(
(
unavailable_cruncher_type,
ReasonedBool(
False,
'The `%s` simpack specified `%s` as the only '
'available cruncher type.' % \
(simpack.__name__.rsplit('.')[-1],
cruncher_type.__name__)
)
) for unavailable_cruncher_type in unavailable_cruncher_types
))
# #
###################################################################
elif cute_iter_tools.is_iterable(CRUNCHERS):
self.available_cruncher_types = []
for item in CRUNCHERS:
if isinstance(item, str):
(cruncher_type,) = \
[cruncher_type_ for cruncher_type_ in
crunchers.cruncher_types_list if
cruncher_type_.__name__ == item]
else:
assert misc_tools.is_subclass(item, BaseCruncher)
cruncher_type = item
self.available_cruncher_types.append(cruncher_type)
self.cruncher_types_availability[cruncher_type] = True
### Giving unavailability reasons: ################################
# #
unavailable_cruncher_types = \
[cruncher_type_ for cruncher_type_ in
crunchers.cruncher_types_list if cruncher_type_ not in
self.available_cruncher_types]
self.cruncher_types_availability.update(dict(
(
unavailable_cruncher_type,
ReasonedBool(
False,
'The `%s` simpack specified a list of available '
'crunchers and `%s` is not in it.' % \
(simpack.__name__.rsplit('.')[-1],
unavailable_cruncher_type.__name__)
)
) for unavailable_cruncher_type in unavailable_cruncher_types
))
# #
###################################################################
elif isinstance(CRUNCHERS, collections.Callable):
assert not isinstance(CRUNCHERS, BaseCruncher)
self.available_cruncher_types = \
[cruncher_type_ for cruncher_type_ in
crunchers.cruncher_types_list if
CRUNCHERS(cruncher_type_)]
for available_cruncher_type in self.available_cruncher_types:
self.cruncher_types_availability[available_cruncher_type] = \
True
### Giving unavailability reasons: ################################
# #
unavailable_cruncher_types = \
[cruncher_type_ for cruncher_type_ in
crunchers.cruncher_types_list if cruncher_type_ not in
self.available_cruncher_types]
for unavailable_cruncher_type in unavailable_cruncher_types:
reason = getattr(
CRUNCHERS(unavailable_cruncher_type),
'reason',
'No reason was given for `%s` not being accepted.' % \
unavailable_cruncher_type.__name__
)
self.cruncher_types_availability[
unavailable_cruncher_type
] = ReasonedBool(False, reason)
# #
###################################################################
#######################################################################
else:
raise InvalidSimpack("The `CRUNCHERS` setting must be either a "
"cruncher type (or name string), a list of "
"cruncher types, or a filter function for "
"cruncher types. You supplied `%s`, which is "
"neither." % CRUNCHERS)
def __init_analysis(self):
'''Analyze the simpack.'''
simpack = self.simpack
try:
State = simpack.State
except AttributeError:
raise InvalidSimpack("The `%s` simpack does not define a `State` "
"class." % simpack.__name__.rsplit('.')[-1])
if not misc_tools.is_subclass(State, garlicsim.data_structures.State):
raise InvalidSimpack("The `%s` simpack defines a `State` class, "
"but it's not a subclass of "
"`garlicsim.data_structures.State`." % \
simpack.__name__.rsplit('.')[-1])
state_methods = dict(
(name, value)
for (name, value) in misc_tools.getted_vars(State).iteritems()
if callable(value))
self.step_functions_by_type = dict(
(step_type, []) for step_type in step_types.step_types_list)
'''dict mapping from each step type to step functions of that type.'''
for method in state_methods.itervalues():
step_type = StepType.get_step_type(method)
if step_type:
self.step_functions_by_type[step_type].append(method)
if self.step_functions_by_type[step_types.HistoryStep] or \
self.step_functions_by_type[step_types.HistoryStepGenerator]:
self.history_dependent = True
self.all_step_functions = (
self.step_functions_by_type[step_types.HistoryStepGenerator] +
self.step_functions_by_type[step_types.HistoryStep])
if (self.step_functions_by_type[step_types.SimpleStep]
or self.step_functions_by_type[step_types.StepGenerator]
or self.step_functions_by_type[step_types.InplaceStep]
or self.step_functions_by_type[
step_types.InplaceStepGenerator]):
raise InvalidSimpack("The `%s` simpack is defining both a "
"history-dependent step and a "
"non-history-dependent step - which "
"is forbidden." % \
simpack.__name__.rsplit('.')[-1])
else: # No history step defined
self.history_dependent = False
self.all_step_functions = (
self.step_functions_by_type[step_types.StepGenerator] + \
self.step_functions_by_type[step_types.SimpleStep] + \
self.step_functions_by_type[step_types.InplaceStepGenerator] +\
self.step_functions_by_type[step_types.InplaceStep]
)
# (no-op assignments, just for docs:)
self.history_dependent = self.history_dependent
'''Flag saying whether the simpack looks at previous states.'''
self.all_step_functions = self.all_step_functions
'''
All the step functions that the simpack provides, sorted by priority.
'''
if not self.all_step_functions:
raise InvalidSimpack("The `%s` simpack has not defined any kind "
"of step function." % \
simpack.__name__.rsplit('.')[-1])
self.default_step_function = self.all_step_functions[0]
'''
def __init_analysis_cruncher_types(self):
'''Figure out which crunchers this simpack can use.'''
# todo: possibly fix `CRUNCHERS` to some canonical state in `.settings`
from garlicsim.asynchronous_crunching import crunchers, BaseCruncher
simpack = self.simpack
self.cruncher_types_availability = OrderedDict()
'''dict mapping from cruncher type to whether it can be used.'''
self.available_cruncher_types = []
'''The cruncher types that this simpack can use.'''
CRUNCHERS = self.settings.CRUNCHERS
if isinstance(CRUNCHERS, basestring):
(cruncher_type,) = \
[cruncher_type_ for cruncher_type_ in
crunchers.cruncher_types_list if
cruncher_type_.__name__ == CRUNCHERS]
self.available_cruncher_types = [cruncher_type]
self.cruncher_types_availability[cruncher_type] = True
### Giving unavailability reasons: ################################
# #
unavailable_cruncher_types = \
[cruncher_type_ for cruncher_type_ in
crunchers.cruncher_types_list if cruncher_type_ not in
self.available_cruncher_types]
self.cruncher_types_availability.update(dict(
(
unavailable_cruncher_type,
ReasonedBool(
False,
'The `%s` simpack specified `%s` as the only '
'available cruncher type.' % \
(simpack.__name__.rsplit('.')[-1],
cruncher_type.__name__)
)
) for unavailable_cruncher_type in unavailable_cruncher_types
))
# #
###################################################################
elif misc_tools.is_subclass(CRUNCHERS, BaseCruncher):
cruncher_type = CRUNCHERS
self.available_cruncher_types = [cruncher_type]
self.cruncher_types_availability[cruncher_type] = True
### Giving unavailability reasons: ################################
# #
unavailable_cruncher_types = \
[cruncher_type_ for cruncher_type_ in
crunchers.cruncher_types_list if cruncher_type_ not in
self.available_cruncher_types]
self.cruncher_types_availability.update(dict(
(
unavailable_cruncher_type,
ReasonedBool(
False,
'The `%s` simpack specified `%s` as the only '
'available cruncher type.' % \
(simpack.__name__.rsplit('.')[-1],
cruncher_type.__name__)
)
) for unavailable_cruncher_type in unavailable_cruncher_types
))
# #
###################################################################
elif cute_iter_tools.is_iterable(CRUNCHERS):
self.available_cruncher_types = []
for item in CRUNCHERS:
if isinstance(item, basestring):
(cruncher_type,) = \
[cruncher_type_ for cruncher_type_ in
crunchers.cruncher_types_list if
cruncher_type_.__name__ == item]
else:
assert misc_tools.is_subclass(item, BaseCruncher)
cruncher_type = item
self.available_cruncher_types.append(cruncher_type)
self.cruncher_types_availability[cruncher_type] = True
### Giving unavailability reasons: ################################
# #
unavailable_cruncher_types = \
[cruncher_type_ for cruncher_type_ in
crunchers.cruncher_types_list if cruncher_type_ not in
self.available_cruncher_types]
self.cruncher_types_availability.update(dict(
(
unavailable_cruncher_type,
ReasonedBool(
False,
'The `%s` simpack specified a list of available '
'crunchers and `%s` is not in it.' % \
(simpack.__name__.rsplit('.')[-1],
unavailable_cruncher_type.__name__)
)
) for unavailable_cruncher_type in unavailable_cruncher_types
))
# #
###################################################################
elif callable(CRUNCHERS):
assert not isinstance(CRUNCHERS, BaseCruncher)
self.available_cruncher_types = \
[cruncher_type_ for cruncher_type_ in
crunchers.cruncher_types_list if
CRUNCHERS(cruncher_type_)]
for available_cruncher_type in self.available_cruncher_types:
self.cruncher_types_availability[available_cruncher_type] = \
True
### Giving unavailability reasons: ################################
# #
unavailable_cruncher_types = \
[cruncher_type_ for cruncher_type_ in
crunchers.cruncher_types_list if cruncher_type_ not in
self.available_cruncher_types]
for unavailable_cruncher_type in unavailable_cruncher_types:
reason = getattr(
CRUNCHERS(unavailable_cruncher_type),
'reason',
'No reason was given for `%s` not being accepted.' % \
unavailable_cruncher_type.__name__
)
self.cruncher_types_availability[
unavailable_cruncher_type] = ReasonedBool(False, reason)
# #
###################################################################
#######################################################################
else:
raise InvalidSimpack("The `CRUNCHERS` setting must be either a "
"cruncher type (or name string), a list of "
"cruncher types, or a filter function for "
"cruncher types. You supplied `%s`, which is "
"neither." % CRUNCHERS)
def test_basics(self):
c = Counter('abcaba')
self.assertEqual(c, Counter({'a':3 , 'b': 2, 'c': 1}))
self.assertEqual(c, Counter(a=3, b=2, c=1))
self.assertIsInstance(c, dict)
self.assertIsInstance(c, Mapping)
self.assertTrue(misc_tools.is_subclass(Counter, dict))
self.assertTrue(misc_tools.is_subclass(Counter, Mapping))
self.assertEqual(len(c), 3)
self.assertEqual(sum(c.values()), 6)
self.assertEqual(sorted(c.values()), [1, 2, 3])
self.assertEqual(sorted(c.keys()), ['a', 'b', 'c'])
self.assertEqual(sorted(c), ['a', 'b', 'c'])
self.assertEqual(sorted(c.items()),
[('a', 3), ('b', 2), ('c', 1)])
self.assertEqual(c['b'], 2)
self.assertEqual(c['z'], 0)
self.assertEqual(c.has_key('c'), True)
self.assertEqual(c.has_key('z'), False)
self.assertEqual(c.__contains__('c'), True)
self.assertEqual(c.__contains__('z'), False)
self.assertEqual(c.get('b', 10), 2)
self.assertEqual(c.get('z', 10), 10)
self.assertEqual(c, dict(a=3, b=2, c=1))
self.assertEqual(repr(c), "Counter({'a': 3, 'b': 2, 'c': 1})")
self.assertEqual(c.most_common(), [('a', 3), ('b', 2), ('c', 1)])
for i in range(5):
self.assertEqual(c.most_common(i),
[('a', 3), ('b', 2), ('c', 1)][:i])
self.assertEqual(''.join(sorted(c.elements())), 'aaabbc')
c['a'] += 1 # increment an existing value
c['b'] -= 2 # sub existing value to zero
del c['c'] # remove an entry
del c['c'] # make sure that del doesn't raise KeyError
c['d'] -= 2 # sub from a missing value
c['e'] = -5 # directly assign a missing value
c['f'] += 4 # add to a missing value
self.assertEqual(c, dict(a=4, b=0, d=-2, e=-5, f=4))
self.assertEqual(''.join(sorted(c.elements())), 'aaaaffff')
self.assertEqual(c.pop('f'), 4)
self.assertNotIn('f', c)
for i in range(3):
elem, cnt = c.popitem()
self.assertNotIn(elem, c)
c.clear()
self.assertEqual(c, {})
self.assertEqual(repr(c), 'Counter()')
self.assertRaises(NotImplementedError, Counter.fromkeys, 'abc')
self.assertRaises(TypeError, hash, c)
c.update(dict(a=5, b=3))
c.update(c=1)
c.update(Counter('a' * 50 + 'b' * 30))
c.update() # test case with no args
c.__init__('a' * 500 + 'b' * 300)
c.__init__('cdc')
c.__init__()
self.assertEqual(c, dict(a=555, b=333, c=3, d=1))
self.assertEqual(c.setdefault('d', 5), 1)
self.assertEqual(c['d'], 1)
self.assertEqual(c.setdefault('e', 5), 5)
self.assertEqual(c['e'], 5)
