ingredient-selector

README.md

Ingredient Selector

Perform a random selection (weighted) of ingredients from the data files.

Development

Update the ingredient files and run! The script will automatically decrement the weights of its selections to promote new items.

Usage

❯ python3 ingredient_selector.py --help
usage: ingredient_selector [-h] [-k K] [-u]

Randomly select ingredients from dataset files for #club-cooking challenge!

optional arguments:
  -h, --help    show this help message and exit
  -k K          Number of random values to return.
  -u, --update  Flag indicating if ingredient weights should be updated.

Example

$ chmod u+x ingredient_selector.py

# Test it out with a random selection.
❯ python3 ingredient_selector.py
fruit.csv: Selected orange at weight 100
vegetable.csv: Selected tomatillo at weight 100
protein.csv: Selected lamb at weight 100

# Make a legit selection and update the weights.
❯ python3 ingredient_selector.py --update
fruit.csv: Selected pear at weight 50
fruit.csv: Updated pear to weight 25

vegetable.csv: Selected asparagas at weight 12
vegetable.csv: Updated asparagas to weight 6

protein.csv: Selected beef at weight 12
protein.csv: Updated beef to weight 6

fruit.csv

ingredient_selector.py

#!/usr/bin/env python3

import argparse
import collections
import csv
import dataclasses
import glob
import io
import random

# List of ingredient files to use.
INGREDIENT_FILES = glob.glob('*.csv')

# Entry represents an individual row from an ingredient file.
@dataclasses.dataclass
class Entry:
  name: str = ""
  weight: str = ""

# Field names for the ingredient files.
FIELDS = ['name', 'weight']

# Returns a new weight for the entry if selected.
def new_weight(entry):
  return entry.weight // 2


# Generator func that yields Entry instances for all entries in the ingredient file.
def read_csv(path):
  with io.open(path, 'r') as csvfile:
    for row in csv.DictReader(csvfile):
#      print(row)
      yield Entry(**row)


# Write ingredient data back to a file. For the entry that was selected
# in this round, we'll store its new weight value to reduce likelihood of it being
# selected soon.
def update_entry_weight_from(path, entries, selection, selection_weight):
  with io.open(path, 'w') as csvfile:
    writer = csv.DictWriter(csvfile, fieldnames=FIELDS)
    writer.writeheader()
    for entry in entries:
      if entry.name == selection.name:
        entry.weight = selection_weight
      writer.writerow(dict(name=entry.name, weight=entry.weight))


# Load ingredient file and make a (weighted) random selection of its entries.
def random_selection_from(entries, k):
  population = [e.name for e in entries]
  weights = [int(e.weight) for e in entries]

  for name in random.choices(population, weights, k=k):
    yield Entry(name, weights[population.index(name)])


def main():
  parser = argparse.ArgumentParser(
    prog='ingredient_selector',
    description='Randomly select ingredients from dataset files for #club-cooking challenge!',
  )
  parser.add_argument(
    '-k',
    action='store',
    default=1,
    type=int,
    help='Number of random values to return.'
  )
  parser.add_argument(
    '-u',
    '--update',
    action='store_true',
    help='Flag indicating if ingredient weights should be updated.'
  )

  args = parser.parse_args()

  for path in INGREDIENT_FILES:
    entries = list(read_csv(path))

    for entry in random_selection_from(entries, args.k):
      print(f'{path}: Selected {entry.name} at weight {entry.weight}')

      if args.update:
        entry_weight = new_weight(entry)
        update_entry_weight_from(path, entries, entry, entry_weight)

        print(f'{path}: Updated {entry.name} to weight {entry_weight}')
        print()

if __name__ == '__main__':
  main()

protein_meat.csv

protein_other.csv

vegetable.csv