def __init__(self,
proxy_api=PROXY_API,
token_file=TOKEN_FILE,
token=API_TOKEN):
self.token = token
self.proxy_api = proxy_api
self.token_file = token_file
self.waiter = Waiter()
def test_notification(self):
factory = BurritoFactory(discount = 0)
order = factory.order_dish()
waiter = Waiter()
order.attach(waiter)
with patch.object(waiter, "update") as mock_update:
order.prepare()
self.assertEqual(mock_update.call_count, 1)
def test_init(self):
w = Waiter("Ron Weasley", 149)
self.assertEqual(w.full_name, "Ron Weasley")
self.assertEqual(w.salary, 149)
self.assertEqual(w.customers_served, 0)
self.assertEqual(self.waiter1.full_name, "Harry Potter")
self.assertEqual(self.waiter1.salary, 150)
self.assertEqual(self.waiter1.customers_served, 42)
def test_if_observer_is_attachable_and_detachable(self):
factory = BurritoFactory(discount = 0)
order = factory.order_dish()
waiter = Waiter()
order.attach(waiter)
self.assertEqual(isinstance(order._observers[0], Waiter), True)
self.assertEqual(len(order._observers), 1)
order.detach(waiter)
self.assertEqual(len(order._observers), 0)
def main():
seed(datetime.now())
o = Owner("owner", 100000)
w1 = Waiter("waiter1", 200000)
w2 = Waiter("waiter2", 200000)
b = Barista("barista", 300000)
waiters = [o, w1, w2]
baristas = [o, b]
for i in range(10):
waiters[randrange(len(waiters))].serve(randrange(1, 3 + 1), baristas[randrange(len(baristas))])
print("")
o.report()
w1.report()
w2.report()
b.report()
def test_serve(self):
# for Ron Weasley
w = Waiter("Ron Weasley", 149)
w.serve(54, self.barista1)
self.assertEqual(w.customers_served, 54)
# for Harry Potter (has already served 42 and serves +31)
self.waiter1.serve(31, self.barista1)
self.assertEqual(self.waiter1.customers_served, 73)
# for Hermione Granger [54 (from Ron) + 31 (from Harry, the 42 from before don't count as they aren't prepared by barista1)
self.assertEqual(self.barista1.customers_served, 85)
print(
f"the Barista {self.barista1.full_name} served {self.barista1.customers_served} customers at the end of the test day"
)
def __init__(self, *, whitelist: List[str], blacklist: List[str],
lf: bool, ff: bool,
arglist: List[str], pyt_arglist: List[str],
verbosity: int, parallel_limit: int,
xfail: List[str], coverage: bool) -> None:
self.whitelist = whitelist
self.blacklist = blacklist
self.arglist = arglist
self.pyt_arglist = pyt_arglist
self.verbosity = verbosity
self.waiter = Waiter(verbosity=verbosity, limit=parallel_limit, xfail=xfail, lf=lf, ff=ff)
self.versions = get_versions()
self.cwd = os.getcwd()
self.env = dict(os.environ)
self.coverage = coverage
def order_dish(self):
self.store = StoreProxy().create_store()
if self.store:
self.waiter = Waiter()
chosen_dish_kind = self.store.choose_dish_kind()
self.factory = self.store.create_factory(chosen_dish_kind)
if self.factory:
order = self.factory.order_dish()
if order:
order.id = len(self.store.orders_list) + 1
order.attach(self.waiter)
self.store.orders_list.append(order)
self.store.orders_list[-1].print_info()
self.store.orders_list[-1].prepare()
def main():
all_menus = Menu('All', 'it is all menu')
lunch_menu = Menu('Lunch', 'it is lunch menu')
dinner_menu = Menu('Dinner', 'it is dinner menu')
drink_menu = Menu('Drink', 'it is drink menu')
dessert_menu = Menu('Dessert', 'it is dessert menu')
all_menus.add_child(lunch_menu)
all_menus.add_child(dinner_menu)
lunch_menu.add_child(MenuItem('beef', '240', 'pan-fried steak'))
lunch_menu.add_child(drink_menu)
drink_menu.add_child(MenuItem('milk tea', '50', 'milk tea without sugar'))
dinner_menu.add_child(MenuItem('salmon', '340', 'pan-fried salmon'))
dinner_menu.add_child(MenuItem('whole wheat bread', '50',
'for vegetarian'))
dinner_menu.add_child(dessert_menu)
dessert_menu.add_child(MenuItem('Waffle', '100', 'delicious'))
waiter = Waiter(all_menus)
waiter.show_menu()
def _load():
global wa, q, data, w
try:
with open(FN_WORKSPACE) as fp:
_workspace = dill.loads(fp.read())
# To store any user data
data = _workspace['data']
wa = _workspace['wa']
q = _workspace['q']
q.connect()
w = _workspace['w']
except IOError:
data = {}
wa = WeiboAutomator()
q = Queue('message.db')
q.connect()
w_timeline = Waiter(200, wa.home_timeline, (), {
'count': 100,
'callback': q.input
})
w = [w_timeline]
def get_my_que(user_address):
user_id = MyUser.get_id_by_email(user_address)
db = get_db()
que_ids = db.execute("SELECT * FROM ques WHERE callee_id = ?",
(user_id, )).fetchall()
# print(que_ids)
que: list[Waiter] = []
for waiter in que_ids:
c_id = waiter[1]
c_user = MyUser.get(c_id)
c_name = c_user.name
c_address = c_user.email
c_phone = c_user.phone
c_waiter = Waiter(email=c_address,
name=c_name,
phone=c_phone,
place=waiter[2])
que.append(c_waiter)
# print("que:", que)
# sort 'que' according to the 'place' attribute of waiter
que.sort(key=lambda x: x.place)
# print("que:", que)
return que
disease1 = Disease('Citrus allergy', [orange, lemon])
disease2 = Disease('Strawberry allergy', [strawberry])
disease3 = Disease('Lactose intolerance', [milk, egg])
disease4 = Disease('Chocolate allergy', [chocolate])
print(disease1)
customer = Customer('Robert', 'Smith', '*****@*****.**',
[disease4])
print(customer)
menu_customer = customer.get_personal_menu(restaurant)
for dish in menu_customer:
print(dish)
waiter = Waiter('Elliot', 'Smith', 35.7)
print(waiter)
order1 = waiter.take_order(customer, [dish2, dish4])
print(order1)
print(order1.get_full_price())
waiter.bring_order(order1)
order1.pay_for_order(60)
print(waiter.get_salary())
restaurant.waiters = [waiter]
restaurant.orders = [order1]
from waiter import Waiter
from item import Item
from menu import Menu
# Creating a menu
# Create a waiter with a menu and add the items
Jared = Waiter("Jared")
Jared.menu.add_item("Pasta", 10)
Jared.menu.add_item("Burger", 12)
Jared.menu.add_item("Smoothie", 5)
Jared.menu.add_item("Salad", 7)
Jared.menu.add_item("Pizza", 15)
Jared.menu.add_item("Large Pizza", 21)
Jared.menu.add_item("Soup of the Day", 8)
Jared.menu.add_item("Falafel Wrap", 11)
Jared.menu.add_item("Curry", 13)
Jared.menu.add_item("Fried Rice", 6)
Jared.menu.add_item("Chips", 3)
print(f"\n Hi there, I'm {Jared.name}. Can I take your order? ")
# This code will run until we insert 4 as a choice
while True:
choice = input("""
1. Show menu
2. Order something
3. Show current order list
4. Finish with ordering
-> """)
parser.add_argument('--year', '-y', type=int, required=True)
parser.add_argument('--queue_size', type=int, default=3)
parser.add_argument('--wait',
'-w',
type=int,
default=10,
help='wait time in seconds')
parser.add_argument('--dir',
'-d',
type=str,
default='cache',
help='cache directory')
parser.add_argument('--useragent', '-ua', type=str, default='')
args = parser.parse_args()
signal.signal(signal.SIGINT, lambda a, b: print('sigint') or exit(1))
c = Keiba(
reporter=Reporter(1),
waiter=Waiter([args.wait]),
outdir=args.dir,
useragent=args.useragent,
)
if args.type == 'race':
asyncio.run(c.run(c.collect(args.year, queue_size=args.queue_size)))
elif args.type == 'horse':
asyncio.run(
c.run(c.collect_horse(args.year, queue_size=args.queue_size)))
else:
print('invalid type')
exit(1)
def test_init(self):
w = Waiter("Tom", 5000)
self.assertEqual(w.full_name, "Tom")
self.assertEqual(w.salary, 5000)
self.assertEqual(w.served_cnt, 0)
def test_serve(self):
w = Waiter("Tom", 5000)
w.serve(50, self.baristaObj)
self.assertEqual(w.served_cnt, 50)
def setUp(self) -> None:
self.waiter1 = Waiter("Harry Potter", 150)
self.waiter1.customers_served = 42
self.barista1 = Barista("Hermione Granger", 160)
##This is a basic OOP project with python
from person import Person
from chef import Chef
from manager import Manager
from waiter import Waiter
from dishwasher import Dishwasher
from client import Client
if __name__ == "__main__":
c = Chef("Jesus", 45, "Male")
m = Manager("Beto", 72, "Male")
w = Waiter("Eduardo", 25, "Male")
d = Dishwasher("Sarah", 33, "Female")
cl = Client("Female")
print(
f"{c.name} is the chef name, is {c.age} years old, and is {c.gender}. {c.cook()}"
)
print(
f"{m.name} is the manager name, is {m.age} years old, and is {m.gender}. {m.management()}"
)
print(
f"{w.name} is the waiter name, is {w.age} years old, and is {w.gender}. {w.serve()}"
)
print(
f"{d.name} is the dishwasher name, is {d.age} years old, and is {d.gender}. {d.wash()}"
)
print(f"The client is a {cl.gender} and {cl.order()}")
def main():
waiter = Waiter(LunchMenu(), DinnerMenu())
waiter.show_menu()
parser = argparse.ArgumentParser('wear')
parser.add_argument('url', action='store', help='URL')
parser.add_argument('--pagestart', '-ps', type=int, required=True)
parser.add_argument('--pageend', '-pe', type=int, required=True)
parser.add_argument('--useragent', '-ua', type=str, default='')
parser.add_argument('--waitlist', '-wl', type=str, default='wait.json')
parser.add_argument('--outdir', '-o', type=str, required=True)
parser.add_argument('--loglevel',
'-ll',
default=2,
type=int,
help='log level')
parser.add_argument(
'--wait',
'-w',
default='5',
nargs='+',
type=str,
help=
'interval for http requests. default is none. `-w 0.5` `-w random 1 2.5`'
)
args = parser.parse_args()
c = WearCollector(reporter=Reporter(args.loglevel),
waiter=Waiter(args.wait, args.waitlist),
outdir=args.outdir,
useragent=args.useragent)
asyncio.run(c.run(c.user_collector(args.url, args.pagestart,
args.pageend)))
