def main_final():
print(
"Welcome to AM's Turf Management System\nPress 1 if you are an existing User\nPress any other key to "
"create an acoount")
n = int(input())
if n == 1:
print(
"Welcome back User\nIf you are an owner press 1\nIf you are an employee/manager press 2\n if you "
"are an customer press 3")
ch = int(input())
if ch == 1:
Owner.owner_main()
elif ch == 2:
Manager.manager_main()
elif ch == 3:
Cust.cust_main()
else:
print("Damn! we think you didn't get that, invalid syntax")
else:
print(
"Press 1 if you want to sign up as a owner\nPress 2 if you want to sign up as a manager\nPress 3 "
"you want to sign up as a Customer")
ch = int(input())
if ch == 1:
user = input("Enter a username of your choice")
passwd = input("enter a pass of your choice")
Creator.creator_ow(user, passwd, 1)
elif ch == 2:
user = input("Enter a username of your choice")
passwd = input("enter a pass of your choice")
Creator.creator_ow(user, passwd, 2)
def authorize():
client_id = int(request.form.get('client_id'))
login = request.form.get('login')
password = request.form.get('password')
state = request.form.get('state', None)
user_db = Owner.db()
if not user_db(login=login):
return redirect(db.client[client_id]['redirect_uri'] +
'?error=access_denied' +
('' if state is None else '&state=' + state),
code=302)
if Owner.db()(login=login)[0]['password'] != sha256(
password.encode('UTF-8')).hexdigest():
print(sha256(password.encode('UTF-8')).hexdigest())
print(password)
return redirect(db.client[client_id]['redirect_uri'] +
'?error=access_denied' +
('' if state is None else '&state=' + state),
code=302)
code = sha256(str(uuid4()).encode('UTF-8')).hexdigest()
db.authorization_code.insert(user_id=Owner.db()(login=login)[0]['__id__'],
code=code,
expire_time=datetime.now() +
timedelta(minutes=10))
db.authorization_code.commit()
return redirect(db.client[client_id]['redirect_uri'] + '?code=' + code +
('' if state is None else '&state=' + state),
code=302)
def music_constructor(cfg, logger, owner: Owner, old=None):
def create():
if name not in TYPE_MAP:
cls = DummyControl
owner.log('Wrong type of player controller - \'{}\''.format(name),
logger_.ERROR)
else:
cls = TYPE_MAP[name]
log = logger.add(name.upper())
try:
return cls(name, cfg['music'], log, owner=owner)
except Exception as e:
log('Init Error: {}'.format(e), logger_.CRIT)
return DummyControl(owner=owner)
if not (old is None or isinstance(old, (BaseControl, DummyControl))):
raise TypeError('Wrong type: {}'.format(type(old)))
name = cfg.gt('music', 'type', '').lower()
if old:
if old.name == name:
old.reload()
return old
else:
owner.join_thread(old)
old = create()
old.start()
else:
old = create()
return old
def authorize():
client_id = int(request.form.get('client_id'))
login = request.form.get('login')
password = request.form.get('password')
state = request.form.get('state', None)
user_db = Owner.db()
if not user_db(login=login):
return redirect(db.client[client_id]['redirect_uri'] +
'?error=access_denied' +
('' if state is None else '&state=' + state), code=302)
if Owner.db()(login=login)[0]['password'] != sha256(password.encode('UTF-8')).hexdigest():
print (sha256(password.encode('UTF-8')).hexdigest())
print (password)
return redirect(db.client[client_id]['redirect_uri'] +
'?error=access_denied' +
('' if state is None else '&state=' + state), code=302)
code = sha256(str(uuid4()).encode('UTF-8')).hexdigest()
db.authorization_code.insert(user_id=Owner.db()(login=login)[0]['__id__'],
code=code,
expire_time=datetime.now() + timedelta(minutes=10))
db.authorization_code.commit()
return redirect(db.client[client_id]['redirect_uri'] +
'?code=' + code +
('' if state is None else '&state=' + state), code=302)
def test_d_has_one_dog_returns_false_with_2_dogs(self):
kennel = Kennel()
owner = Owner('id', 'first_name', 'last_name', 'birth_date', kennel)
owner.add_dog('name1', 'breed1', 'gender1', 'favorite_food1')
owner.add_dog('name2', 'breed2', 'gender2', 'favorite_food2')
returned = owner.has_one_dog()
assert returned == False
def unsubscribe(self, own: Owner):
with self._lock:
if not self._subscribers:
return
self._subscribers -= 1
if not self._subscribers:
own.unsubscribe(self._events, self._cb, SELF_AUTH_CHANNEL)
self._owners.clear()
def upgrade_duplex(own: Owner, soc: Connect, msg=''):
cmd = 'upgrade duplex'
if own.has_subscribers(cmd, cmd):
lock = Unlock()
own.sub_call(cmd, cmd, msg, lock, soc)
lock.wait(30)
else:
raise RuntimeError('No subscribers: {}'.format(cmd))
def __init__(self, tmp_own: Owner):
super().__init__(name='Logger')
self._queue = queue.Queue()
self._call_event = tmp_own.registration(self.EVENT)
tmp_own.subscribe(self.EVENT, self._event)
self.cfg, self.own = None, None
self.file_lvl = None
self.print_lvl = None
self.in_print = None
self._handler = None
self._app_log = None
self._await = None
self.remote_log = None
self.log = self.add('Logger')
self.log('start', INFO)
def init_owners(self):
"""
>>> state = DraftState({})
>>> owners = state.init_owners()
>>> for o in owners:
... print o
Owner with picks: [1, 20, 21, 40, 41, 60, 61, 80, 81, 100, 101, 120, 121, 140, 141, 160]
Owner with picks: [2, 19, 22, 39, 42, 59, 62, 79, 82, 99, 102, 119, 122, 139, 142, 159]
Owner with picks: [3, 18, 23, 38, 43, 58, 63, 78, 83, 98, 103, 118, 123, 138, 143, 158]
Owner with picks: [4, 17, 24, 37, 44, 57, 64, 77, 84, 97, 104, 117, 124, 137, 144, 157]
Owner with picks: [5, 16, 25, 36, 45, 56, 65, 76, 85, 96, 105, 116, 125, 136, 145, 156]
Owner with picks: [6, 15, 26, 35, 46, 55, 66, 75, 86, 95, 106, 115, 126, 135, 146, 155]
Owner with picks: [7, 14, 27, 34, 47, 54, 67, 74, 87, 94, 107, 114, 127, 134, 147, 154]
Owner with picks: [8, 13, 28, 33, 48, 53, 68, 73, 88, 93, 108, 113, 128, 133, 148, 153]
Owner with picks: [9, 12, 29, 32, 49, 52, 69, 72, 89, 92, 109, 112, 129, 132, 149, 152]
Owner with picks: [10, 11, 30, 31, 50, 51, 70, 71, 90, 91, 110, 111, 130, 131, 150, 151]
"""
owners = []
# i is the owner number
for i in range(1, self.round_length + 1):
picks = []
# j is the round number
for j in range(self.num_rounds):
if j % 2 == 0:
pick = i + self.round_length * j
else:
pick = self.round_length - i + 1 + self.round_length * j
picks.append(pick)
owner = Owner(picks, name=str(i))
owners.append(owner)
return owners
def set_team_personnel(self):
"""Set the personnel working for this team.
In this method, we set attributes pertaining to the actual baseball-class objects
corresponding to the employees of this organization. This method may be called any
time an employee in the organization quits, retires, is fired, or dies.
"""
# Set team owner
owner_person = next(e for e in self.organization.employees
if isinstance(e, BaseballTeamOwner)).person
self.owner = Owner(
person=owner_person
) if not owner_person.team_owner else owner_person.team_owner
# Set manager
manager_person = next(e for e in self.organization.employees
if isinstance(e, BaseballManager)).person
self.manager = (Manager(person=manager_person, team=self) if
not manager_person.manager else manager_person.manager)
# Set scout
scout_person = next(e for e in self.organization.employees
if isinstance(e, BaseballScout)).person
self.scout = Scout(
person=scout_person,
team=self) if not scout_person.scout else scout_person.scout
# Set personnel attribute
self.personnel = {self.owner, self.manager, self.scout}
for p in self.personnel:
p.team = self
def getOwnerData(self, fileName):
f = open(fileName, 'r')
for line in f:
splitLine = re.split('[|]', line)
fullName = splitLine[0]
email = splitLine[1]
newOwner = Owner(fullName.strip(), email.strip())
self.ownerList.append(newOwner)
class Manage():
while True:
select = input('''
请选择功能：
1.停车
2.出车
''')
if select == '1':
#车主进入停车场
owner1 = Owner('7', '18973678899')
owner1.enter_carport()
Car.car_license = input('让我记录您的车牌号：')
#记录进入停车场时间
record1 = Record(Car.car_license, '', '', '', '')
record1.enter_time = time.time()
print('进入停车场时间是：', record1.enter_time)
#开始停车
car1 = Car(Car.car_license, 'suv', '1.6l', 'Benz', 'black')
car1.start_park()
#记录开始停车时间
record1.start_time = time.time()
#开始停车时间
print('开始停车时间是：', record1.start_time)
#剩余车位
Carport.surplus -= 1
print('剩余车位：', Carport.surplus)
elif select == '2':
#停止停车
car1.end_park()
car1.end_park()
#记录停止停车时间
record1.end_time = time.time()
#计算停车时间
delta_T = record1.end_time - record1.enter_time
#停车时间小于一小时按一小时计算
if delta_T < 3600:
print('您需交停车费4元')
Order.cost = 4
owner1.pay_money()
#车主离开停车场
owner1.leave_carport()
#记录出停车场时间
record1.leave_time = time.time()
else:
Order.cost = delta_T // 3600 * 4
print('您需交停车费', Order.cost, '元')
owner1.pay_money()
owner1.leave_carport()
record1.leave_time = time.time()
Carport.surplus += 1
print('剩余车位：', Carport.surplus)
else:
print('请正确选择')
time.sleep(2)
continue
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_a_owner_properties(self):
cattery = Cattery()
owner = Owner('1', 'A', 'B', 2, cattery)
assert hasattr(owner, 'id')
assert hasattr(owner, 'first_name')
assert hasattr(owner, 'last_name')
assert hasattr(owner, 'amount_owed')
assert hasattr(owner, 'my_cattery')
assert hasattr(owner, 'all_my_cats')
assert type(owner.all_my_cats) == list
def test_a_owner_properties(self):
kennel = Kennel()
owner = Owner('1', 'A', 'B', 2, kennel)
assert hasattr(owner, 'id')
assert hasattr(owner, 'first_name')
assert hasattr(owner, 'last_name')
assert hasattr(owner, 'birth_date')
assert hasattr(owner, 'my_kennel')
assert hasattr(owner, 'all_my_dogs')
assert type(owner.all_my_dogs) == list
def server_constructor(cfg,
logger,
owner: Owner,
old=None) -> MDTServer or DummyServer:
on = not cfg.gt('smarthome', 'disable_server')
if old is None:
old = MDTServer(cfg=cfg, log=logger.add('Server'),
owner=owner) if on else DummyServer()
if isinstance(old, DummyServer):
old = MDTServer(cfg=cfg, log=logger.add('Server'),
owner=owner) if on else old
old.start()
elif isinstance(old, MDTServer):
if not on:
owner.join_thread(old)
old = DummyServer()
else:
raise TypeError('Wrong type: {}'.format(type(old)))
return old
def __init__(self, cfg, log, owner: Owner):
self.log = log
self.cfg = cfg
self.own = owner
self.sys_say = Phrases(log, cfg)
self._lock = threading.Lock()
self._work = True
self._start_stt_event = owner.registration('start_stt_event')
self._stop_stt_event = owner.registration('stop_stt_event')
try:
self.max_mic_index = len(sr.Microphone().list_microphone_names()) - 1
try:
with sr.Microphone(device_index=self.get_mic_index()) as _:
pass
except OSError as e:
if e.errno == -9996:
raise
except OSError as e:
self.log('Error get list microphones: {}'.format(e), logger.CRIT)
self.max_mic_index = -2
def test():
date1 = date(1999, 5, 5)
date2 = date(2000, 5, 5)
date3 = date(2002, 5, 1)
date4 = date(2022, 5, 1)
date5 = date(2022, 5, 2)
dog1 = Dog("firulais", date1, "galgo")
dog2 = Dog("cholo", date2, "pitbull")
dogs = [dog1, dog2]
owner1 = Owner("Diego", "123456789-1", [dog1, dog2])
dog3 = Dog("cleo", date3, "golden retriever")
owner1.add_dog(dog3)
dogs = owner1.dogs
race1 = Race(date4, dogs)
race2 = Race(date5, dogs)
races = [race1, race2]
event1 = Event(date4, date5, "Santiago", races)
race1.run_race()
positions_table = race1.make_positions_table()
print(positions_table)
def __init__(self):
self.modules = list() #Command Modules
self.cmds = {} #Commands
self.cmdescs = {} #command Descriptions
self.bot = Bot(None)
self.pref = "//"
self.link = "https://discordapp.com/oauth2/authorize?client_id=354353934074380298&scope=bot&permissions=271674432"
self.owner = None #Owner Info
self.servers = {}
#Adding Commands
if Owner(self).open():
self.modules.append(Owner(self))
self.cmdescs.update(Owner(self).settings().descs)
for a in Owner(self).lis:
self.cmds[a] = Command(a, self.modules[0].lis[a])
if Roles(self).open():
self.modules.append(Roles(self))
self.cmdescs.update(Roles(self).settings().descs)
for a in Roles(self).lis:
self.cmds[a] = Command(a, self.modules[1].lis[a])
if Filter(self).open():
self.modules.append(Filter(self))
self.cmdescs.update(Filter(self).settings().descs)
for a in Filter(self).lis:
self.cmds[a] = Command(a, self.modules[2].lis[a])
if Utility(self).open():
self.modules.append(Utility(self))
self.cmdescs.update(Utility(self).settings().descs)
for a in Utility(self).lis:
self.cmds[a] = Command(a, self.modules[3].lis[a])
if Chat(self).open():
self.modules.append(Chat(self))
self.cmdescs.update(Chat(self).settings().descs)
for a in Chat(self).lis:
self.cmds[a] = Command(a, self.modules[4].lis[a])
if Entertainment(self).open():
self.modules.append(Entertainment(self))
self.cmdescs.update(Entertainment(self).settings().descs)
for a in Entertainment(self).lis:
self.cmds[a] = Command(a, self.modules[5].lis[a])
def test_g_add_cat_increases_cat_count(self):
cattery = Cattery()
owner = Owner('1', 'A', 'B', 2, cattery)
owner.add_cat('name1', 'breed1', 'gender1', 'secret_name1')
assert len(owner.all_my_cats) == 1
owner.add_cat('name2', 'breed2', 'gender2', 'secret_name2')
assert len(owner.all_my_cats) == 2
def test_g_add_dog_increases_dog_count(self):
kennel = Kennel()
owner = Owner('1', 'A', 'B', 2, kennel)
owner.add_dog('name1', 'breed1', 'gender1', 'favorite_food1')
assert len(owner.all_my_dogs) == 1
owner.add_dog('name2', 'breed2', 'gender2', 'favorite_food2')
assert len(owner.all_my_dogs) == 2
def create_owners_and_cats(self):
self.owners = []
self.cats = []
station_ids = self.tfl_connections.get_all_stations()
for idx in range(1, self.num_cats + 1):
owner_posn, cat_posn = random.sample(station_ids, 2)
cat = Cat(idx, cat_posn)
owner = Owner(idx, owner_posn)
self.owners.append(owner)
self.cats.append(cat)
from owner import Owner
from vehicle import Vehicle
import os
name = input('Insira seu nome completo: ')
identity = input('Insira seu numero da identidade: ')
cpd = input('Insira o numero da sua carteira de motorista: ')
birth = input('Insira a sua data de nascimento: ')
qtd = int(input('Quantos veiculos voce tem? '))
owner = Owner(name, birth, identity, cpd)
for i in range(0, qtd):
print('Carro' + str(i + 1))
model = input('Qual o modelo do carro?')
plate = input('Qual a placa do carro?')
color = input('Qual a cor do carro?')
vehicle = Vehicle(plate, model, color)
owner.addVehicle(vehicle)
class TestOneToManyRelationships(unittest.TestCase):
global driver_1
driver_1 = Driver("Dwight Schrute")
global trip_1
trip_1 = Trip("11 Broadway, NY, NY", "123 Smith Street, BK, NY", driver_1)
global trip_2
trip_2 = Trip("Pier 11 Ferry", "Battery Park", driver_1)
global trip_3
trip_3 = Trip("Wall Street", "Lincoln Center", driver_1)
global owner_1
owner_1 = Owner("Michael Scott", 38)
global car_1
car_1 = Car("Ford", "Aerostar Minivan", 1997, owner_1)
global car_2
car_2 = Car("Toyota", "Corolla", 2000, owner_1)
global car_3
car_3 = Car("Chrysler", "300C", 2008, owner_1)
def test_owner_property_methods(self):
self.assertEqual(owner_1._name, "Michael Scott")
self.assertEqual(owner_1.name, "Michael Scott")
self.assertEqual(owner_1._age, 38)
self.assertEqual(owner_1.age, 38)
def test_driver_property_methods(self):
self.assertEqual(driver_1._name, "Dwight Schrute")
self.assertEqual(driver_1.name, "Dwight Schrute")
def test_car_property_methods(self):
self.assertEqual(car_1._make, "Ford")
self.assertEqual(car_1.make, "Ford")
self.assertEqual(car_1._model, "Aerostar Minivan")
self.assertEqual(car_1.model, "Aerostar Minivan")
self.assertEqual(car_1._year, 1997)
self.assertEqual(car_1.year, 1997)
self.assertEqual(car_1._owner, owner_1)
self.assertEqual(car_1.owner, owner_1)
def test_trip_property_methods(self):
self.assertEqual(trip_3._start, "Wall Street")
self.assertEqual(trip_3.start, "Wall Street")
self.assertEqual(trip_3._destination, "Lincoln Center")
self.assertEqual(trip_3.destination, "Lincoln Center")
self.assertEqual(trip_3._driver, driver_1)
self.assertEqual(trip_3.driver, driver_1)
def test_car_class_method(self):
self.assertItemsEqual(Car._all, [car_1, car_2, car_3])
self.assertItemsEqual(Car.all(), [car_1, car_2, car_3])
def test_trip_class_method(self):
self.assertItemsEqual(Trip._all, [trip_1, trip_2, trip_3])
self.assertItemsEqual(Trip.all(), [trip_1, trip_2, trip_3])
def test_find_my_cars_instance_method(self):
self.assertItemsEqual(
owner_1.find_my_cars(),
["Ford Aerostar Minivan", "Toyota Corolla", "Chrysler 300C"])
def test_my_trips_instance_method(self):
self.assertItemsEqual(driver_1.my_trips(), [trip_1, trip_2, trip_3])
def test_find_my_cars_instance_method(self):
self.assertItemsEqual(driver_1.my_trip_summaries(), [
"11 Broadway, NY, NY to 123 Smith Street, BK, NY",
"Pier 11 Ferry to Battery Park", "Wall Street to Lincoln Center"
])
def add_owner(self, new_id, new_first_name, new_last_name, new_birth_date):
new_owner = Owner(new_id, new_first_name, new_last_name,
new_birth_date, self)
self.all_my_owners.append(new_owner)
def test_f_owner_add_cat_exists(self):
cattery = Cattery()
owner = Owner('1', 'A', 'B', 2, cattery)
assert hasattr(owner, 'add_cat')
assert callable(getattr(owner, 'add_cat', None))
def add_owner(flat):
name, surname, phone = view.get_new_owner()
owner = Owner(name, surname, phone)
flat.add_owner(owner)
def owner():
from owner import Owner
return Owner(identity(), make_jack=False)
def test_f_owner_add_dog_exists(self):
kennel = Kennel()
owner = Owner('1', 'A', 'B', 2, kennel)
assert hasattr(owner, 'add_dog')
assert callable(getattr(owner, 'add_dog', None))
# MicroPython One Time Password Generator
# Copyright (C) 2016 Guido Dassori <*****@*****.**>
# MIT License
from core import Core
from owner import Owner
core = Core()
owner = Owner(core)
def run(owner):
from utime import sleep
sleep(0.1)
from gc import collect
from machine import I2C, Pin, RTC
bus = I2C(-1, Pin(4), Pin(5))
from urtc import DS3231
rtc = RTC()
dl = [x for x in DS3231(bus).datetime() if x]
rtc.datetime(dl + [0 for x in range(0, 8 - len(dl))])
del I2C, Pin, DS3231, rtc, dl
collect()
sleep(0.2)
from gc import collect
from states import init
init_state = init()
owner.core.load()
collect()
init_state.on_enter(owner)
def test_a_owner_has_one_dog_exists(self):
kennel = Kennel()
owner = Owner('id', 'first_name', 'last_name', 'birth_date', kennel)
assert hasattr(owner, 'has_one_dog')
assert callable(getattr(owner, 'has_one_dog', None))
def build_owners(self):
for row in self.owner_rows:
owner = Owner(row.get('id'))
owner.name = row.get_element_by_id('ownerspan' + owner.id).text_content()
self.owners.add(owner)
