body {
color: #00ff00;
}

pip install aloe

Feature: Compute factorial

In order to play with aloe
As beginners
We'll implement factorial

Scenario: Factorial of 0
Given I have the number 0
When I compute its factorial
Then I see the number 1

from aloe import before, step, world

@before.each_example
def clear(*args):
pass

@step(r'I have the number (\d+)')
def have_the_number(self, number):
world.number = int(number)

@step(r'I compute its factorial')
def check_number(self):
world.number = factorial(world.number)

@step(r'I see the number (\d+)')
def check_number(self, expected):
expected = int(expected)
assert world.number == expected, f'エラー: 期待値 {expected}, 計算値 {world.number}'

def factorial(number):
return -1

FAIL: Factorial of 0 (a_aloe_first: Compute factorial)

...

AssertionError: エラー: 期待値 1, 計算値 -1

----------------------------------------------------------------------
Ran 1 test in 0.001s

FAILED (failures=1)

Ran 1 test in 0.000s

OK

pizzas = [item for item in tab.items if item.type == 'pizza']
if len(pizzas) > 2 and day_of_week == 4:
cheapest_pizza_price = min([pizza.price for pizza in pizzas])
tab.add_dicsount(cheapest_pizza_price)

if 17 < hour_now < 19:
for item in tab.items:
if item.type == 'drink':
item.price = item.price * 0.90

if tab.customer.is_member():
item.price = item.price * 0.85

If tab contains 2 pizzas on Wednesdays cheapest one is free.
(水曜日に２つ以上のピザの購入で、安い方は無料)

Every day from 17:00 to 19:00 drinks are less 10%
All items are less 15% for members
(毎日１７時から１９時の間はドリンク全品１０％ OFF)
(メンバーは全ての商品１５％ OFF)

rule: "If ", conditions, " then ", item_type, " get ", discount

conditions: condition | conditions " and " conditions | conditions " or " conditions
condition: time_condition | item_condition | customer_condition

discount: number, "% discount" | "cheapest ", number, item_type " free"

time_condition: "today is ", day_of_week | "time is between ", time, " and ", time | "today is a week day" | "today not a week day"
day_of_week: "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday"
time: hours, ":", minutes
hours: hour_tens, hour_ones
hour_tens: "0" | "1"
hour_ones: digit
minutes: minute_tens, minute_ones
minute_tens: "0" | "1" | "2" | "3" | "4" | "5"
minute_ones: digit

item_condition: "item is a ", item_type | "there are ", number, " of ", item_type
item_type: "pizza" | "burger" | "drink" | "chips"

number: {digit}
digit: "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"

customer_conditions: "customer is a ", customer_type
customer_type: "member" | "non-member"

class Tab:
pass

class Item:
pass

class Customer:
pass

class Discount:
pass

class Rule:
pass

class CustomerType:
pass

class ItemType:
pass

class Conditions:
pass

class Condition:
pass

class TimeCondition:
pass

class DayOfWeek:
pass

class Time:
pass

class Hours:
pass

class HourTens:
pass

class HourOnes:
pass

class Minutes:
pass

class MinuteTens:
pass

class MinuteOnes:
pass

class ItemCondition:
pass

class Number:
pass

class Digit:
pass

class CustomerCondition:
pass

class Leaf:
def __init__(self, *args, **kwargs):
pass

def component_function(self):
print('Leaf')


class Composite:
def __init__(self, *args, **kwargs):
self.children = []

def component_function(self):
for child in children:
child.component_function()

def add(self, child):
self.children.append(child)

def remove(self, child):
self.children.remove(child)

from math import floor


class CustomerType:
def __init__(self, customer_type: str):
self.customer_type = customer_type


class Customer:
def __init__(self, customer_type: CustomerType, name: str):
self.customer_type = customer_type
self.name = name

def is_a(self, customer_type: CustomerType) -> bool:
return self.customer_type == customer_type


class ItemType:
def __init__(self, name: str):
self.name = name


class Item:
def __init__(self, name: str, item_type: ItemType, cost: int):
self.name = name
self.item_type = item_type
self.cost = cost


class Tab:
def __init__(self, customer: Customer):
self.items: list[Item] = []
self.discounts: list[int] = []
self.customer = customer

def calculate_cost(self) -> int:
return sum(x.cost for x in self.items)

def calculate_discount(self) -> int:
return sum(x for x in self.discounts)


class Discount:
def __init__(self, amount: int):
self.amount = amount


class Rule:
def __init__(self, tab: Tab):
self.tab = tab
self.conditions: list[bool] = []
self.discounts: list[Discount] = []

def add_condition(self, test_value: bool):
self.conditions.append(test_value)

def add_percentage_discount(self, item_type: str, percent: int):
if item_type == 'any item':
f = lambda x: True
else:
f = lambda x: x.item_type == item_type

items_to_discount = [item for item in self.tab.items if f(item)]
for item in items_to_discount:
discount = Discount(floor(item.cost * (percent / 100.0)))
self.discounts.append(discount)

def apply(self) -> int:
if all(self.conditions):
return sum(x.amount for x in self.discounts)
return 0


if __name__ == '__main__':
member = CustomerType('Member')
non_member = CustomerType('Non-membger')

member_customer = Customer(member, 'John')
tab = Tab(member_customer)

pizza = ItemType('Pizza')
burger = ItemType('Burger')
drink = ItemType('Drink')

tab.items.append(Item('ペスカトーレ', pizza, 1600))
tab.items.append(Item('フィレオフィッシュ', burger, 350))
tab.items.append(Item('マンゴージュース', drink, 650))

rule = Rule(tab)
rule.add_condition(tab.customer.is_a(member))
rule.add_percentage_discount('any item', 15)

tab.discounts.append(rule.apply())

print(
f'合計金額: {tab.calculate_cost()}円\n'
f'割引金額: {tab.calculate_discount()}円\n'
f'支払金額: {tab.calculate_cost() - tab.calculate_discount()}円\n'
f'割引率: {round(100 * tab.calculate_discount() / tab.calculate_cost(), 2)}%'
)

from collections.abc import Callable


class Item:
"""
タイプヒントを付けるための便宜上のクラス定義
"""
def __init__(self, name: str):
self.name = name


class Tab:
"""
タイプヒントを付けるための便宜上のクラス定義
"""
def __init__(self):
self.items: list[Item] = []


class CompositeConditionBase:
"""
タイプヒントを付けるための便宜上の抽象インターフェースクラス定義
"""
def evaluate(self, tab: Tab) -> bool:
pass

def add(self, condition: CompositeConditionBase):
pass

def remove(self, condition: CompositeConditionBase):
pass


class Condition(CompositeConditionBase):
def __init__(self, condition_function: Callable[[Tab], bool]):
self.test = condition_function

def evaluate(self, tab: Tab) -> bool:
return self.test(tab)


class AndConditions(CompositeConditionBase):
def __init__(self):
self.conditions: list[CompositeConditionBase] = []

def evaluate(self, tab: Tab) -> bool:
return all(x.evaluate(tab) for x in self.conditions)

def add(self, condition: CompositeConditionBase):
self.conditions.append(condition)

def remove(self, condition: CompositeConditionBase):
self.conditions.remove(condition)


class OrConditions(CompositeConditionBase):
def __init__(self):
self.conditions: list[CompositeConditionBase] = []

def evalueate(self, tab: Tab) -> bool:
return any(x.evaluate(tab) for x in self.conditions)

def add(self, condition: CompositeConditionBase):
self.conditions.append(condition)

def remove(self, condition: CompositeConditionBase):
self.conditions.remove(condition)


class Discount:
def __init__(self, test_function: Callable[[Item], bool], discount_function: Callable[[Item], int]):
self.test = test_function
self.discount = discount_function

def calculate(self, tab: Tab) -> int:
return sum(self.discount(item) for item in tab.items if self.test(item))


class Discounts:
def __init__(self):
self.children: list[Discount] = []

def calculate(self, tab: Tab) -> int:
return sum(x.calculate(tab) for x in self.children)

def add(self, child: Discount):
self.children.append(child)

def remove(self, child: Discount):
self.children.remove(child)


class Rule:
def __init__(self, tab: Tab):
self.tab = tab
self.conditions = AndConditions()
self.discounts = Discounts()

def add_conditions(self, conditions: CompositeConditionBase):
self.conditions.add(conditions)

def add_discount(self, test_function: Callable[[Item], bool], discount_function: Callable[[Item], int]):
discount = Discount(test_function, discount_function)
self.discounts.add(discount)

def apply(self) -> int:
if self.conditions.evaluate(self.tab):
return self.discounts.calculate(self.tab)
return 0