176 lines
8.2 KiB
Python
176 lines
8.2 KiB
Python
import re
|
|
|
|
from django.core.cache import caches
|
|
from django.db.models.functions import Lower
|
|
|
|
from cookbook.models import Automation
|
|
|
|
|
|
class AutomationEngine:
|
|
request = None
|
|
use_cache = None
|
|
food_aliases = None
|
|
keyword_aliases = None
|
|
unit_aliases = None
|
|
never_unit = None
|
|
transpose_words = None
|
|
description_replace = None
|
|
instruction_replace = None
|
|
|
|
def __init__(self, request, use_cache=True):
|
|
self.request = request
|
|
self.use_cache = use_cache
|
|
|
|
def apply_keyword_automation(self, keyword):
|
|
keyword = keyword.strip()
|
|
if self.use_cache and self.keyword_aliases is None:
|
|
self.keyword_aliases = {}
|
|
KEYWORD_CACHE_KEY = f'automation_keyword_alias_{self.request.space.pk}'
|
|
if c := caches['default'].get(KEYWORD_CACHE_KEY, None):
|
|
self.keyword_aliases = c
|
|
caches['default'].touch(KEYWORD_CACHE_KEY, 30)
|
|
else:
|
|
for a in Automation.objects.filter(space=self.request.space, disabled=False, type=Automation.KEYWORD_ALIAS).only('param_1', 'param_2').order_by('order').all():
|
|
self.keyword_aliases[a.param_1.lower()] = a.param_2
|
|
caches['default'].set(KEYWORD_CACHE_KEY, self.keyword_aliases, 30)
|
|
else:
|
|
self.keyword_aliases = {}
|
|
if self.keyword_aliases:
|
|
try:
|
|
keyword = self.keyword_aliases[keyword.lower()]
|
|
except KeyError:
|
|
pass
|
|
else:
|
|
if automation := Automation.objects.filter(space=self.request.space, type=Automation.KEYWORD_ALIAS, param_1__iexact=keyword, disabled=False).order_by('order').first():
|
|
return automation.param_2
|
|
return keyword
|
|
|
|
def apply_unit_automation(self, unit):
|
|
unit = unit.strip()
|
|
if self.use_cache and self.unit_aliases is None:
|
|
self.unit_aliases = {}
|
|
UNIT_CACHE_KEY = f'automation_unit_alias_{self.request.space.pk}'
|
|
if c := caches['default'].get(UNIT_CACHE_KEY, None):
|
|
self.unit_aliases = c
|
|
caches['default'].touch(UNIT_CACHE_KEY, 30)
|
|
else:
|
|
for a in Automation.objects.filter(space=self.request.space, disabled=False, type=Automation.UNIT_ALIAS).only('param_1', 'param_2').order_by('order').all():
|
|
self.unit_aliases[a.param_1.lower()] = a.param_2
|
|
caches['default'].set(UNIT_CACHE_KEY, self.unit_aliases, 30)
|
|
else:
|
|
self.unit_aliases = {}
|
|
if self.unit_aliases:
|
|
try:
|
|
unit = self.unit_aliases[unit.lower()]
|
|
except KeyError:
|
|
pass
|
|
else:
|
|
if automation := Automation.objects.filter(space=self.request.space, type=Automation.UNIT_ALIAS, param_1__iexact=unit, disabled=False).order_by('order').first():
|
|
return automation.param_2
|
|
return unit
|
|
|
|
def apply_food_automation(self, food):
|
|
food = food.strip()
|
|
if self.use_cache and self.food_aliases is None:
|
|
self.food_aliases = {}
|
|
FOOD_CACHE_KEY = f'automation_food_alias_{self.request.space.pk}'
|
|
if c := caches['default'].get(FOOD_CACHE_KEY, None):
|
|
self.food_aliases = c
|
|
caches['default'].touch(FOOD_CACHE_KEY, 30)
|
|
else:
|
|
for a in Automation.objects.filter(space=self.request.space, disabled=False, type=Automation.FOOD_ALIAS).only('param_1', 'param_2').order_by('order').all():
|
|
self.food_aliases[a.param_1.lower()] = a.param_2
|
|
caches['default'].set(FOOD_CACHE_KEY, self.food_aliases, 30)
|
|
else:
|
|
self.food_aliases = {}
|
|
|
|
if self.food_aliases:
|
|
try:
|
|
return self.food_aliases[food.lower()]
|
|
except KeyError:
|
|
return food
|
|
else:
|
|
if automation := Automation.objects.filter(space=self.request.space, type=Automation.FOOD_ALIAS, param_1__iexact=food, disabled=False).order_by('order').first():
|
|
return automation.param_2
|
|
return food
|
|
|
|
def apply_never_unit_automation(self, tokens):
|
|
"""
|
|
Moves a string that should never be treated as a unit to next token and optionally replaced with default unit
|
|
e.g. NEVER_UNIT: param1: egg, param2: None would modify ['1', 'egg', 'white'] to ['1', '', 'egg', 'white']
|
|
or NEVER_UNIT: param1: egg, param2: pcs would modify ['1', 'egg', 'yolk'] to ['1', 'pcs', 'egg', 'yolk']
|
|
:param1 string: string that should never be considered a unit, will be moved to token[2]
|
|
:param2 (optional) unit as string: will insert unit string into token[1]
|
|
:return: unit as string (possibly changed by automation)
|
|
"""
|
|
|
|
if self.use_cache and self.never_unit is None:
|
|
self.never_unit = {}
|
|
NEVER_UNIT_CACHE_KEY = f'automation_never_unit_{self.request.space.pk}'
|
|
if c := caches['default'].get(NEVER_UNIT_CACHE_KEY, None):
|
|
self.never_unit = c
|
|
caches['default'].touch(NEVER_UNIT_CACHE_KEY, 30)
|
|
else:
|
|
for a in Automation.objects.filter(space=self.request.space, disabled=False, type=Automation.NEVER_UNIT).only('param_1', 'param_2').order_by('order').all():
|
|
self.never_unit[a.param_1.lower()] = a.param_2
|
|
caches['default'].set(NEVER_UNIT_CACHE_KEY, self.never_unit, 30)
|
|
else:
|
|
self.never_unit = {}
|
|
|
|
new_unit = None
|
|
alt_unit = self.apply_unit_automation(tokens[1])
|
|
never_unit = False
|
|
if self.never_unit:
|
|
try:
|
|
new_unit = self.never_unit[tokens[1].lower()]
|
|
never_unit = True
|
|
except KeyError:
|
|
return tokens
|
|
else:
|
|
if a := Automation.objects.annotate(param_1_lower=Lower('param_1')).filter(space=self.request.space, type=Automation.NEVER_UNIT, param_1_lower__in=[
|
|
tokens[1].lower(), alt_unit.lower()], disabled=False).order_by('order').first():
|
|
new_unit = a.param_2
|
|
never_unit = True
|
|
|
|
if never_unit:
|
|
tokens.insert(1, new_unit)
|
|
return tokens
|
|
|
|
def apply_transpose_automation(self, string):
|
|
"""
|
|
If two words (param_1 & param_2) are detected in sequence, swap their position in the ingredient string
|
|
:param 1: first word to detect
|
|
:param 2: second word to detect
|
|
return: new ingredient string
|
|
"""
|
|
if self.use_cache and self.transpose_words is None:
|
|
self.transpose_words = {}
|
|
TRANSPOSE_WORDS_CACHE_KEY = f'automation_transpose_words_{self.request.space.pk}'
|
|
if c := caches['default'].get(TRANSPOSE_WORDS_CACHE_KEY, None):
|
|
self.transpose_words = c
|
|
caches['default'].touch(TRANSPOSE_WORDS_CACHE_KEY, 30)
|
|
else:
|
|
i = 0
|
|
for a in Automation.objects.filter(space=self.request.space, disabled=False, type=Automation.TRANSPOSE_WORDS).only('param_1', 'param_2').order_by('order').all():
|
|
self.transpose_words[i] = [a.param_1.lower(), a.param_2.lower()]
|
|
i += 1
|
|
caches['default'].set(TRANSPOSE_WORDS_CACHE_KEY, self.transpose_words, 30)
|
|
else:
|
|
self.transpose_words = {}
|
|
|
|
tokens = [x.lower() for x in string.replace(',', ' ').split()]
|
|
if self.transpose_words:
|
|
for key, value in self.transpose_words.items():
|
|
if value[0] in tokens and value[1] in tokens:
|
|
string = re.sub(rf"\b({value[0]})\W*({value[1]})\b", r"\2 \1", string, flags=re.IGNORECASE)
|
|
else:
|
|
for rule in Automation.objects.filter(space=self.request.space, type=Automation.TRANSPOSE_WORDS, disabled=False) \
|
|
.annotate(param_1_lower=Lower('param_1'), param_2_lower=Lower('param_2')) \
|
|
.filter(param_1_lower__in=tokens, param_2_lower__in=tokens).order_by('order'):
|
|
if rule.param_1 in tokens and rule.param_2 in tokens:
|
|
string = re.sub(rf"\b({rule.param_1})\W*({rule.param_2})\b", r"\2 \1", string, flags=re.IGNORECASE)
|
|
return string
|
|
|
|
def apply_regex_replace_automation(self, string):
|
|
return string
|