import random
 import collections
 import itertools
 import re
 
 basestr = (str,unicode)
 
 class DieJar(object):
 	parser = re.compile(r'^(?:_?(?P<num>[1-9][0-9]*))?d(?P<sides>[1-9][0-9]*)$')
 	def __getattr__(self, key):
 		out = []
 		for sect in key.split('__'):
 			out.extend(self.parse_section(sect))
 		return Dice(out)
 
 	def parse_section(self, key):
 		out = self.parser.match(key)
 		if out is None:
 			raise AttributeError('invalid die specification')
 		else:
 			dct = out.groupdict()
 			dct['sides'] = int(dct['sides'])
 			dct['num'] = int(dct['num'] or 1)
 			dice = [Die(dct['sides']) for __ in range(dct['num'])]
 			return dice
 
 
 
 
 
 def iterable(obj):
 	return (not isinstance(obj, basestr)) and isinstance(obj, collections.Iterable)
 
 def flatten(lis):
 	return itertools.chain(*[(x if iterable(x) else [x]) for x in lis])
 
 class Die(object):
 	'Note: hashed by sides, min and step.  Consequently not necessarily preserved when used as a dictionary key'
 	def __init__(self, sides, min=1, step=1):
 		self.sides = sides
 		self.min = min
 		self.step = 1
 		self.sides = sides
 		self.choices = range(min, (min+sides)*step, step)
 		self._value = None
 		self.combine_func = lambda a,b: a+b
 
 	def roll(self):
 		self._value = random.choice(self.choices)
 		return self._value
 
 	@property
 	def value(self):
 		if self._value is None: self.roll()
 		return self._value
 
 	def combine(self, other):
 		if hasattr(other, 'value'): other = other.value
 		return self.combine_func(self.value, other.value)
 
 	def __str__(self):
 		base = 'd%d' % self.sides
 		if self.min != 1:
 			base = '%s+%d' % (base,self.min)
 		if self.step != 1:
 			base = '(%s)*%d' % (base, self.step)
 		return base
 
 	def __eq__(self, other):
 		return (self.sides == other.sides) and (self.min == other.min) and (self.step == other.step)
 
 	def __hash__(self):
 		return hash((self.sides,self.min,self.step))
 
 class Dice(collections.Sequence):
 	'A collection of dice, can be initialized either with Die instances or lists of Die instances'
 
 	def __init__(self, *dice, **kw):
 		self.dice = list(flatten(dice))
 		self.combiner = kw.get('combiner', lambda a,b:a+b)
 
 	def __getitem__(self, k): return self.dice[k]
 	def __len__(self): return len(self.dice)
 
 	def roll(self):
 		return reduce(self.combiner, (die.roll() for die in self.dice))
 	def __str__(self):
 		groups = collections.Counter(self.dice)
 		out = []
 		dice = sorted(groups, key=lambda k:-groups[k])
 		if len(dice) > 1:
 			for die in dice[:-1]:
 				count = groups[die]
 				out.append('%d%s' % (count,die))
 			out = ','.join(out)
 			out = ' and '.join([out, str(dice[-1])])
 		else:
 			out = '%d%s' % (groups[dice[0]],dice[0])
 
 
 		return out
 
 
 
 MULT=1
 ADD=2
 class DieRoll(object):
 	def __init__(self, dice=None, adjustments=None):
 		self.dice = dice
 		self.adjustments = [] if adjustments is None else adjustments
 
 	def add_adjustment(self, add=None, mult=None):
 		if None not in {add,mult}: raise ValueError('can\'t add two adjustments at once')
 		elif {add,mult} - {None} == set(): raise ValueError('No adjustment given')
 
 		if add is not None:
 			adjustment = (ADD,add)
 		elif mult is not None:
 			adjustment = (MULT,mult)
 		self.adjustments.append(adjustment)
 
 	def roll(self):
 		result = self.dice.roll()
 		for type,bonus in self.adjustments:
 			if type == MULT:
 				result *= type
 			elif type == ADD:
 				result += bonus
 		return result
 
 if __name__ == '__main__':
 	import unittest
 	tests = unittest.TestSuite()
 	inst = lambda a:a()
 
 	class TestDie(unittest.TestCase):
 		def test_roll_plain(self):
 			a = Die(6)
 			for __ in range(40):
 				self.assertLess(a.roll(), 7)
 				self.assertGreater(a.roll(), 0)
 		def test_roll_min(self):
 			a = Die(6,min=4)
 			for __ in range(40):
 				self.assertLess(a.roll(), 6+4+1)
 				self.assertGreater(a.roll(), 3)
 		def test_roll_step(self):
 			a = Die(6,step=2)
 			for __ in range(40):
 				self.assertLess(a.roll(), 6+(6*2)+1)
 				self.assertGreater(a.roll(), 0)
 				self.assertTrue((a.roll()-1) % 2 == 0)
 		def test_str(self):
 			self.assertEqual(str(Die(6)), 'd6')
 			self.assertEqual(str(Die(6,min=2)), 'd6+2')
 
 	class TestDice(unittest.TestCase):
 		def test_init(self):
 			dice = [Die(6) for __ in range(20)]
 			a = Dice(dice)
 			self.assertEqual(dice,a.dice)
 			a = Dice(*dice)
 			self.assertEqual(dice,a.dice)
 		def test_roll(self):
 			dice = [Die(6) for __ in range(2)]
 			dice = Dice(dice)
 			self.assertGreater(dice.roll(), 1)
 			self.assertLess(dice.roll(), 13)
 
 	class TestDieRoll(unittest.TestCase):
 		pass
 
 	unittest.main()