def _fill_in(seeds, i, distance=1):
if seeds[i] is None:
# Check for neighbours
if i - distance >= 0 and seeds[i - distance]:
neighbour = seeds[i - distance]
try:
related = conceptnet.get_weighted_related_words(neighbour, 25)
if len(related) == 0:
related = conceptnet.get_weighted_related_words(
normalise_seed(neighbour), 25
)
except Exception as e:
logger.info("Conceptnet related words failing: {}".format(e))
related = []
normalised_related = map(normalise_weighted_word, related)
# pool = multiprocessing.Pool()
# normalised_related = pool.map(normalise_weighted_word, related)
# pool.close()
filtered_related = [
weighted_word
for weighted_word in normalised_related
if not weighted_word[1] in seeds and len(weighted_word[1]) > 2
]
if len(filtered_related) > 0:
seeds[i] = normalise_seed(random_util.weighted_random(filtered_related))
# Check if still unassigned
if seeds[i] is None:
_fill_in(seeds, i, distance + 1)
def __call__(self, presentation_context) -> Optional[ImageData]:
logger.debug('Calling generator_util.ExternalImageListGenerator')
logger.debug('self._image_generator: {}'.format(self._image_generator))
logger.debug('self._check_image_validness: {}'.format(
self._check_image_validness))
logger.debug('self._weighted: {}'.format(self._weighted))
logger.debug('module where function def: {}'.format(
self._image_generator.__module__))
logger.debug(
'****************************************************************')
images = self._image_generator(presentation_context)
logger.debug('images: {}'.format(images))
logger.debug(
'****************************************************************')
while bool(images) and len(images) > 0:
original_chosen_image = (random_util.weighted_random([
image for image in images if image[0] > 0
]) if self._weighted else random.choice(images))
if isinstance(original_chosen_image, str):
chosen_image = ImageData(image_url=original_chosen_image)
elif isinstance(original_chosen_image, ImageData):
chosen_image = original_chosen_image
else:
logger.warning(
"INVALID IMAGE INPUT FOR EXTERNAL IMAGE GENERATOR / " +
str(original_chosen_image) + " / " +
str(type(original_chosen_image)))
images.remove(original_chosen_image)
continue
return chosen_image
return None
def _fill_in(seeds, i, distance=1):
if seeds[i] is None:
# Check for neighbours
if i - distance >= 0 and seeds[i - distance]:
neighbour = seeds[i - distance]
try:
related = conceptnet.get_weighted_related_words(neighbour, 200)
except Exception as e:
print('Conceptnet related words failing: {}'.format(e))
related = []
filtered_related = [
word for word in related
if not normalise_seed(word[1]) in seeds
and len(normalise_seed(word[1])) > 2
]
if len(filtered_related) > 0:
seeds[i] = normalise_seed(
random_util.weighted_random(filtered_related))
# Check if still unassigned
if seeds[i] is None:
_fill_in(seeds, i, distance + 1)
def test_weighted_random_all_appear_double_values(self):
possibilities = (.1, "one"), (.4, "four"), (.6, "six"), (.7, "seven")
results = set()
for _ in range(1000):
if len(results) == len(possibilities):
break
results.add(random_util.weighted_random(possibilities))
self.assertEqual({"one", "four", "six", "seven"}, results)
def __call__(self, seed):
current_weighted_generators = list(self._weighted_generators)
while len(current_weighted_generators) > 0:
# print("combined generator using", current_weighted_generators)
generator = random_util.weighted_random(current_weighted_generators)
generated = generator(seed)
if generated is not None:
return generated
_remove_object_from_weighted_list(current_weighted_generators, generator)
def _select_generator(self, slide_nr, total_slides, prohibited_generators):
"""Select a generator for a certain slide number"""
logging.debug(
'presentation_schema._select_generator self._slide_generators: {}'.
format(self._slide_generators))
logging.debug('self._ignore_weights: {}'.format(self._ignore_weights))
if self._ignore_weights:
return random_util.choice_optional(self._slide_generators)
_selected_generator = random_util.weighted_random(
self._get_weighted_generators_for_slide_nr(slide_nr, total_slides,
prohibited_generators))
logging.debug('_selected_generator: {}'.format(_selected_generator))
return _selected_generator
def test_weighted_random_all_appear_double_values_appearances(self):
possibilities = (.1, "one"), (.4, "four")
ones = 0
fours = 0
for _ in range(1000):
generated = random_util.weighted_random(possibilities)
if generated == "one":
ones += 1
elif generated == "four":
fours += 1
# Ones should appear 1/5 * 1000 ~ 200 times
self.assertTrue(150 < ones < 250)
# Ones should appear 4/5 * 1000 ~ 800 times
self.assertTrue(750 < fours < 850)
def __call__(self, seed: Union[str, Dict[str, str]]):
logger.debug('Calling generator_util.CombinedGenerator')
current_weighted_generators = list(self._weighted_generators)
logger.debug("current_weighted_generators: {}".format(
current_weighted_generators))
while len(current_weighted_generators) > 0:
generator = random_util.weighted_random(
current_weighted_generators)
logger.debug("current generator: {}".format(generator))
logger.debug("generator seed: {}".format(seed))
generated = generator(seed)
logger.debug("generated: {}".format(generated))
if generated is not None:
return generated
_remove_object_from_weighted_list(current_weighted_generators,
generator)
def __call__(self, argument):
weighted_list = self._weighted_list_creator(argument)
if weighted_list:
return random_util.weighted_random(weighted_list)
def _select_generator(self, slide_nr, total_slides, prohibited_generators):
"""Select a generator for a certain slide number"""
return random_util.weighted_random(
self._get_weighted_generators_for_slide_nr(slide_nr, total_slides,
prohibited_generators))
