dicetables 4.0.2__py3-none-any.whl

dicetables/__init__.py

@@ -0,0 +1,13 @@
+from dicetables.additiveevents import AdditiveEvents
+from dicetables.dicepool_collection import BestOfDicePool, WorstOfDicePool, UpperMidOfDicePool, LowerMidOfDicePool
+from dicetables.dicepool import DicePool
+from dicetables.dicerecord import DiceRecord
+from dicetables.dicetable import DiceTable, DetailedDiceTable
+from dicetables.dieevents import Die, ModDie, WeightedDie, ModWeightedDie, StrongDie, Modifier, ExplodingOn, Exploding
+from dicetables.eventsbases.eventerrors import DiceRecordError, InvalidEventsError
+from dicetables.eventsinfo import (EventsCalculations, EventsInformation,
+                                   events_range, mean, stddev, percentage_points, percentage_axes, stats,
+                                   full_table_string)
+from dicetables.parser import Parser, ParseError
+from dicetables.tools.limit_checker import LimitsError
+from dicetables.roller import Roller

dicetables/additiveevents.py

@@ -0,0 +1,71 @@
+"""
+AdditiveEvents is the general case for DiceTable - an IntegerEvents that can combine with other IntegerEvents.
+"""
+from typing import TypeVar, Type, Dict
+
+from dicetables.eventsbases.integerevents import IntegerEvents
+from dicetables.factory.eventsfactory import EventsFactory
+from dicetables.tools.dictcombiner import DictCombiner
+
+
+def scrub_zeroes(dictionary):
+    return {key: val for key, val in dictionary.items() if val}
+
+
+T = TypeVar('T', bound='AdditiveEvents')
+
+
+class AdditiveEvents(IntegerEvents):
+
+    def __init__(self, events_dict):
+        """
+
+        :param events_dict: {event: occurrences}\n
+            event=int. occurrences=int >=0
+            total occurrences > 0
+        """
+        self._table = scrub_zeroes(events_dict)
+        super(AdditiveEvents, self).__init__()
+        EventsFactory.check(self.__class__)
+
+    @classmethod
+    def new(cls: Type[T]) -> T:
+        return EventsFactory.new(cls)
+
+    def get_dict(self) -> Dict[int, int]:
+        return self._table.copy()
+
+    def __str__(self):
+        min_event = min(self._table.keys())
+        max_event = max(self._table.keys())
+        return 'table from {} to {}'.format(min_event, max_event)
+
+    def combine(self: T, events: IntegerEvents, times: int = 1) -> T:
+        dictionary = DictCombiner(self.get_dict()).combine_by_fastest(events.get_dict(), times)
+        return EventsFactory.from_dictionary(self, dictionary)
+
+    def combine_by_flattened_list(self: T, events: IntegerEvents, times: int = 1) -> T:
+        """
+
+        :WARNING - UNSAFE METHOD: len(flattened_list) = total occurrences of events.
+            if this list is too big, it will raise MemoryError or OverflowError
+        """
+        dictionary = DictCombiner(self.get_dict()).combine_by_flattened_list(events.get_dict(), times)
+        return EventsFactory.from_dictionary(self, dictionary)
+
+    def combine_by_dictionary(self: T, events: IntegerEvents, times: int = 1) -> T:
+        dictionary = DictCombiner(self.get_dict()).combine_by_dictionary(events.get_dict(), times)
+        return EventsFactory.from_dictionary(self, dictionary)
+
+    def combine_by_indexed_values(self: T, events: IntegerEvents, times: int = 1) -> T:
+        dictionary = DictCombiner(self.get_dict()).combine_by_indexed_values(events.get_dict(), times)
+        return EventsFactory.from_dictionary(self, dictionary)
+
+    def remove(self: T, events: IntegerEvents, times: int = 1) -> T:
+        """
+
+        :WARNING - UNSAFE METHOD: There is no record of what you added to an AdditiveEvents.
+            If you remove what you haven't added, no error will be raised, but you will have bugs.
+        """
+        dictionary = DictCombiner(self.get_dict()).remove_by_tuple_list(events.get_dict(), times)
+        return EventsFactory.from_dictionary(self, dictionary)

dicetables/dicepool.py

@@ -0,0 +1,36 @@
+from typing import Dict, Tuple
+
+from dicetables.eventsbases.protodie import ProtoDie
+from dicetables.tools.orderedcombinations import ordered_combinations_of_events
+
+
+class DicePool(object):
+    def __init__(self, input_die: ProtoDie, pool_size: int):
+        if pool_size < 1:
+            raise ValueError("Minimum DicePool size is 1")
+        self._input_die = input_die
+        self._pool_size = pool_size
+        self._rolls = ordered_combinations_of_events(input_die, pool_size)
+
+    @property
+    def die(self) -> ProtoDie:
+        return self._input_die
+
+    @property
+    def size(self) -> int:
+        return self._pool_size
+
+    @property
+    def rolls(self) -> Dict[Tuple[int, ...], int]:
+        return self._rolls.copy()
+
+    def __eq__(self, other):
+        if not isinstance(other, DicePool):
+            return False
+        return (self.die, self.size) == (other.die, other.size)
+
+    def __hash__(self):
+        return hash((self.die, self.size))
+
+    def __repr__(self):
+        return "{}({!r}, {})".format(self.__class__.__name__, self.die, self.size)

dicetables/dicepool_collection.py

@@ -0,0 +1,140 @@
+from typing import Dict
+
+from dicetables.dieevents import ProtoDie
+from dicetables.dicepool import DicePool
+
+
+class DicePoolCollection(ProtoDie):
+    """
+    The abstract class for all DicePoolCollection objects. A DicePoolCollection creates a new die by selecting from a
+    DicePool. Select determines how many rolls are selected from the pool of total rolls.
+    Different implementations determine which particular rolls to select.
+    """
+
+    def __init__(self, pool: DicePool, select: int):
+        """
+
+        :param pool: the dice pool to select from
+        :param select: int <= `pool.size`. How many dice to select from the pool.
+        """
+        self._dice_pool = pool
+        if select > self._dice_pool.size:
+            raise ValueError('you cannot select more dice than the pool_size.')
+        self._select = select
+        self._dict = self._generate_dict()
+        super(DicePoolCollection, self).__init__()
+
+    def _generate_dict(self):
+        raise NotImplementedError
+
+    def get_pool(self) -> DicePool:
+        return self._dice_pool
+
+    def get_select(self) -> int:
+        return self._select
+
+    def get_dict(self) -> Dict[int, int]:
+        return self._dict.copy()
+
+    def get_size(self) -> int:
+        return self._dice_pool.die.get_size() * self._select
+
+    def get_weight(self) -> int:
+        return self._dice_pool.die.get_weight() * self._select
+
+    def weight_info(self):
+        input_die = self._dice_pool.die
+        original_weight_info = input_die.weight_info().replace(str(input_die), 'input_die info:')
+        return '{}\n{}'.format(self, original_weight_info)
+
+    def multiply_str(self, number):
+        return '{}({})'.format(number, self)
+
+    def __str__(self):
+        descriptor = self.__class__.__name__.replace('OfDicePool', '')
+        return '{} {} of {}'.format(descriptor, self._select, self._dice_pool.die.multiply_str(self._dice_pool.size))
+
+    def __repr__(self):
+        return '{}({!r}, {})'.format(
+            self.__class__.__name__, self._dice_pool, self._select
+        )
+
+
+class BestOfDicePool(DicePoolCollection):
+    """
+    Take the best [select] rolls from a DicePool of [pool_size] * [input_die].
+    BestOfDicePool(DicePool(Die(6), 4), 3) is the best 3 rolls from four six-sided dice.
+    """
+
+    def __init__(self, pool: DicePool, select: int):
+        super().__init__(pool, select)
+
+    def _generate_dict(self):
+        ordered_combinations = self._dice_pool.rolls
+        start_at = self._dice_pool.size - self._select
+        stop_before = self._dice_pool.size
+        return generate_events_dict(ordered_combinations, start_at, stop_before)
+
+
+class WorstOfDicePool(DicePoolCollection):
+    """
+    Take the worst [select] rolls from a DicePool of [pool_size] * [input_die].
+    WorstOfDicePool(DicePool(Die(6), 4), 3) is the worst 3 rolls from four six-sided dice.
+    """
+
+    def __init__(self, pool: DicePool, select: int):
+        super().__init__(pool, select)
+
+    def _generate_dict(self):
+        ordered_combinations = self._dice_pool.rolls
+        start_at = 0
+        stop_before = self._select
+        return generate_events_dict(ordered_combinations, start_at, stop_before)
+
+
+class UpperMidOfDicePool(DicePoolCollection):
+    """
+    Take the middle [select] rolls from a DicePool of [pool_size] * [input_die].
+    UpperMidOfDicePool(DicePool(Die(6), 5), 3) is the middle 3 rolls from five six-sided dice.
+
+    If there is no perfect middle, take the higher of two choices. For five dice that roll
+    (1, 1, 2, 3, 4), select=3 takes (1, 2, 3) and select=2 takes (2, 3).
+    """
+
+    def __init__(self, pool: DicePool, select: int):
+        super().__init__(pool, select)
+
+    def _generate_dict(self):
+        ordered_combinations = self._dice_pool.rolls
+        end_slice, extra = divmod(self._dice_pool.size - self._select, 2)
+        start_at = end_slice + extra
+        stop_before = self._dice_pool.size - end_slice
+        return generate_events_dict(ordered_combinations, start_at, stop_before)
+
+
+class LowerMidOfDicePool(DicePoolCollection):
+    """
+    Take the middle [select] rolls from a DicePool of [pool_size] * [input_die].
+    LowerMidOfDicePool(DicePool(Die(6), 5), 3) is the middle 3 rolls from five six-sided dice.
+
+    If there is no perfect middle, take the lower of two choices. For five dice that roll
+    (1, 1, 2, 3, 4), select=3 takes (1, 2, 3) and select=2 takes (1, 2).
+    """
+
+    def __init__(self, pool: DicePool, select: int):
+        super().__init__(pool, select)
+
+    def _generate_dict(self):
+        ordered_combinations = self._dice_pool.rolls
+        end_slice, extra = divmod(self._dice_pool.size - self._select, 2)
+        start_at = end_slice
+        stop_before = self._dice_pool.size - (end_slice + extra)
+        return generate_events_dict(ordered_combinations, start_at, stop_before)
+
+
+def generate_events_dict(ordered_combinations, start_at, stop_before) -> Dict[int, int]:
+    master_dict = {}
+    for key, val in ordered_combinations.items():
+        master_key = sum(key[start_at:stop_before])
+        master_dict[master_key] = master_dict.get(master_key, 0) + val
+    return master_dict

dicetables/dicerecord.py

@@ -0,0 +1,69 @@
+"""
+An immutable record of dice added to and removed from DiceTable
+"""
+from typing import Dict
+
+from dicetables.eventsbases.eventerrors import DiceRecordError
+from dicetables.eventsbases.protodie import ProtoDie
+
+
+class RecordVerifier(object):
+    @staticmethod
+    def check_types(die_input):
+        if any(not isinstance(die, ProtoDie) or not isinstance(num, int) for die, num in die_input.items()):
+            raise DiceRecordError('input must be {ProtoDie: int, ...}')
+
+    @staticmethod
+    def check_negative(die_input):
+        for key, val in die_input.items():
+            if val < 0:
+                raise DiceRecordError('Tried to create a DiceRecord with a negative value at {!r}: {}'.format(key, val))
+
+    @staticmethod
+    def check_number(num):
+        if num < 0:
+            raise DiceRecordError('Tried to add_die or remove_die with a negative number.')
+
+
+def scrub_zeroes(input_dict):
+    return {key: val for key, val in input_dict.items() if val}
+
+
+class DiceRecord(object):
+    def __init__(self, dice_number_dict: Dict[ProtoDie, int]):
+        RecordVerifier.check_types(dice_number_dict)
+        RecordVerifier.check_negative(dice_number_dict)
+        self._record = scrub_zeroes(dice_number_dict)
+
+    @classmethod
+    def new(cls) -> 'DiceRecord':
+        return cls({})
+
+    def get_dict(self) -> Dict[ProtoDie, int]:
+        return self._record.copy()
+
+    def get_number(self, query_die: ProtoDie) -> int:
+        return self._record.get(query_die, 0)
+
+    def add_die(self, die: ProtoDie, times: int) -> 'DiceRecord':
+        RecordVerifier.check_number(times)
+        new = self._record.copy()
+        new[die] = times + self.get_number(die)
+        return DiceRecord(new)
+
+    def remove_die(self, die: ProtoDie, times: int) -> 'DiceRecord':
+        RecordVerifier.check_number(times)
+        new = self._record.copy()
+        new[die] = self.get_number(die) - times
+        return DiceRecord(new)
+
+    def __eq__(self, other):
+        if not isinstance(other, DiceRecord):
+            return False
+        return self.get_dict() == other.get_dict()
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __repr__(self):
+        return 'DiceRecord({!r})'.format(self._record)

dicetables/dicetable.py

@@ -0,0 +1,111 @@
+"""
+DiceTable and DetailedDiceTable compute combination of Die events
+"""
+
+from typing import TypeVar
+
+from dicetables import DiceRecord
+from dicetables.additiveevents import AdditiveEvents
+from dicetables.eventsbases.protodie import ProtoDie
+from dicetables.eventsinfo import EventsCalculations, EventsInformation
+from dicetables.factory.eventsfactory import EventsFactory
+from dicetables.tools.dictcombiner import DictCombiner
+
+T = TypeVar('T', bound='DiceTable')
+
+
+class DiceTable(AdditiveEvents):
+    def __init__(self, events_dict: dict, dice_record: DiceRecord):
+        self._record = dice_record
+        super(DiceTable, self).__init__(events_dict)
+
+    def dice_data(self) -> DiceRecord:
+        return self._record
+
+    def get_list(self):
+        """
+
+        :return: sorted copy of dice list: [(die, number of dice), ...]
+        """
+        return sorted(self._record.get_dict().items())
+
+    def number_of_dice(self, query_die: ProtoDie) -> int:
+        return self._record.get_number(query_die)
+
+    def weights_info(self):
+        """
+
+        :return: str: complete info for all dice
+        """
+        output = ''
+        for die, number in self.get_list():
+            output += format_die_info(die, number)
+        return output.rstrip('\n')
+
+    def __str__(self):
+        str_list = [die.multiply_str(number) for die, number in self.get_list()]
+        return '\n'.join(str_list)
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+        dice = str(self).replace('\n', ', ')
+        return '<{} containing [{}]>'.format(class_name, dice)
+
+    def add_die(self: T, die: ProtoDie, times: int = 1) -> T:
+        """
+
+        :param die: any subclass of ProtoDie: Die, ModDie, WeightedDie, ModWeightedDie, Modifier,
+            StrongDie, Exploding, ExplodingOn
+        :param times: int>= 0
+        """
+        dice_data = self._record.add_die(die, times)
+        dictionary = DictCombiner(self.get_dict()).combine_by_fastest(die.get_dict(), times)
+        return EventsFactory.from_dictionary_and_dice(self, dictionary, dice_data)
+
+    def remove_die(self: T, die: ProtoDie, times=1) -> T:
+        """
+
+        :param die: any subclass of ProtoDie: Die, ModDie, WeightedDie, ModWeightedDie, Modifier,
+            StrongDie, Exploding, ExplodingOn
+        :param times: 0 <= int <= number of "die" in table
+        """
+        dice_data = self._record.remove_die(die, times)
+        dictionary = DictCombiner(self.get_dict()).remove_by_tuple_list(die.get_dict(), times)
+        return EventsFactory.from_dictionary_and_dice(self, dictionary, dice_data)
+
+    def __eq__(self, other):
+        return super(DiceTable, self).__eq__(other) and self.dice_data() == other.dice_data()
+
+
+def format_die_info(die, number):
+    weight_info = die.weight_info()
+    adjusted_info = weight_info.replace(str(die), die.multiply_str(number)) + '\n\n'
+    return adjusted_info
+
+
+class DetailedDiceTable(DiceTable):
+    def __init__(self, events_dict: dict, dice_record: DiceRecord, calc_includes_zeroes: bool = True):
+        super(DetailedDiceTable, self).__init__(events_dict, dice_record)
+        self._calc = EventsCalculations(self, calc_includes_zeroes)
+
+    @property
+    def info(self) -> EventsInformation:
+        return self._calc.info
+
+    @property
+    def calc(self) -> EventsCalculations:
+        return self._calc
+
+    @property
+    def calc_includes_zeroes(self) -> bool:
+        return self._calc.include_zeroes
+
+    def switch_boolean(self: T) -> T:
+        """
+
+        :return: a new DetailedDiceTable with the `calc_includes_zeroes` boolean switched
+        """
+        return EventsFactory.from_params(self, {'calc_includes_zeroes': not self.calc_includes_zeroes})
+
+    def __eq__(self, other):
+        return super(DetailedDiceTable, self).__eq__(other) and self.calc_includes_zeroes == other.calc_includes_zeroes