def __init__(self):
self.factory = MailListFactory()
self.cp = CommandParser()
self.lists = {}
self.db_path = "lists/"
self._load_initial_state()
self._init_callbacks()
self._loop()
def __init__(self, conn, addr, *args, **kwargs):
self.conn = conn
self.addr = addr
self.isLive = True
self.conn.send(b'Connection accepted by server.')
self.receiveThread = threading.Thread(target=self.recv)
self.receiveThread.start()
self.commandParser = CommandParser()
self.id = None
self.isInitialized = False
def __init__(self, screenObj, quit_signal):
"""Initialize all the things the client will need to control the entire user session"""
# initialize screen
self.screen = Screen(screenObj, self.do_command)
self.screen.draw_screen()
# Start listening for messages in the buffer
self.buffer = queue.SimpleQueue()
self.parse_message_thread = threading.Thread(target=self.parse_messages, daemon=True)
self.parse_message_thread.start()
# We are passed a signal to quit the program
self.quit_signal = quit_signal
# Initialize various helper classes
self.settings = Settings()
self.command_parser = CommandParser()
# Create state the client needs to track
self.irc = False
self.connected = False
self.reset_state()
# This needs to be done after reset_state()
self.server_parser = ServerParser(self.nick, self.set_nick)
self.screen.put_line('>>WWWelcome to the wwwiggleVerse!!!')
self.screen.put_line('>>This is free software, type /version for details')
# for _ in range (3):
# with open('test.txt') as f:
# for line in f.readlines():
# self.screen.put_line(line)
def create(self):
"""
returns a list of commmandparser.CommandParser seperated
by the proper Pipe
"""
lst = []
for i, t in enumerate(self.tokens):
if t in '|| | && & >> > << <'.split():
lst.append(PIPES[t])
elif self.tokens[i - 1] in '<'.split():
lst.append(open(t))
elif self.tokens[i - 1] in '<<':
lst.append(open(t, 'r+'))
elif self.tokens[i - 1] == '>>':
lst.append(open(t, 'a'))
elif self.tokens[i - 1] == '>':
lst.append(open(t, 'w'))
else:
lst.append(CommandParser(t))
return lst
async def command_ygg(app: GraiaMiraiApplication, group: Group,
_gm: GroupMessage):
CP = CommandParser(_gm, settings.commandSymbol)
_playerName = CP.Command.args if CP.Command.args else CP.quote_plain_message
_player = PlayerProfile(_playerName)
_message = _player.getYgg()
await app.sendGroupMessage(group, MessageChain.create(_message))
async def command_ban(app: GraiaMiraiApplication, group: Group,
_gm: GroupMessage):
CP = CommandParser(_gm, settings.commandSymbol)
def add() -> str:
_l = str()
for t in CP.at:
targetGP = groupPermissions(t.target)
if not targetGP.isAdmin():
_result = targetGP.blockme()
_message = f'{t.display} {tF.ban.add_succ}\n' if _result else f'{t.display} {tF.ban.add_fail}\n'
_l = f'{_l}{_message}'
return _l.strip('\n')
def remove() -> str:
_l = str()
for t in CP.at:
targetGP = groupPermissions(t.target)
_result = targetGP.unblockme()
_message = f'{t.display} {tF.ban.remove_succ}\n' if _result else f'{t.display} {tF.ban.remove_fail}\n'
_l = f'{_l}{_message}'
return _l.strip('\n')
if CP.Command.args:
subCommand = CP.Command.argsList[0]
if subCommand == 'add':
await app.sendGroupMessage(group,
MessageChain.create([Plain(add())]))
if subCommand == 'remove':
await app.sendGroupMessage(group,
MessageChain.create([Plain(remove())]))
class Chickenfoot:
def __init__(self):
self.modules = {}
self.communicator = None
self.cparser = CommandParser()
def init_from_file(self, filename):
json_file_content = open(filename, 'r').read()
params = json.loads(json_file_content)
if 'nanpy_dev' in params['communication']:
serial_manager.connect(params['communication']['nanpy_dev'])
self.set_communication(params['communication']['type'], **params['communication']['parameters'])
for module in params['modules']:
self.add_module(module['name'], module['type'], **module['parameters'])
def set_communication(self, comm_name, **data):
self.communicator = get_communication(comm_name, **data)
def add_module(self, id, module_name, **data):
self.modules[id] = get_module(module_name, **data)
def listen(self):
self.communicator.listen()
while 1:
data = self.communicator.receive()
if data:
(module, action, parameters) = self.cparser.parse(data)
if parameters:
self.modules[module].execute(action, **parameters)
else:
self.modules[module].execute(action)
self.communicator.close()
class Chickenfoot:
def __init__(self):
self.modules = {}
self.communicator = None
self.cparser = CommandParser()
def init_from_file(self, filename):
json_file_content = open(filename, 'r').read()
params = json.loads(json_file_content)
if 'nanpy_dev' in params['communication']:
serial_manager.connect(params['communication']['nanpy_dev'])
self.set_communication(params['communication']['type'],
**params['communication']['parameters'])
for module in params['modules']:
self.add_module(module['name'], module['type'],
**module['parameters'])
def set_communication(self, comm_name, **data):
self.communicator = get_communication(comm_name, **data)
def add_module(self, id, module_name, **data):
self.modules[id] = get_module(module_name, **data)
def listen(self):
self.communicator.listen()
while 1:
data = self.communicator.receive()
if data:
(module, action, parameters) = self.cparser.parse(data)
if parameters:
self.modules[module].execute(action, **parameters)
else:
self.modules[module].execute(action)
self.communicator.close()
def __init__(self):
self.factory = MailListFactory()
self.cp = CommandParser()
self.lists = []
self._load_initial_state()
self._init_callbacks()
self._loop()
def __init__(self):
self.cp = CommandParser()
self.lists = {}
self.db_path = "lists/"
self.adapter = SQLRelationList(self.db_path)
self._load_initial_state()
self._init_callbacks()
self._loop()
def __init__(self):
self.db_path = "maillist"
self.conn=sqlite3.connect(self.db_path)
self.create_table(self.conn.cursor())
self.factory = MailListDataBaseFactory(self.conn)
self.cp = CommandParser()
self.lists = {}
self._load_initial_state()
self._init_callbacks()
self._loop()
async def command_ot(app: GraiaMiraiApplication, group: Group,
_gm: GroupMessage):
CP = CommandParser(_gm, settings.commandSymbol)
atList: List[Optional[At]] = [At(t.target)
for t in CP.at] if CP.at != [] else []
await app.sendGroupMessage(
group,
MessageChain.create([
*atList,
Image.fromLocalFile('./images/off-topic.png'),
*([Plain(tF.ot)] if group.id == settings.specialqq.littleskin_main
else []) # 仅在 LittleSkin 主群中启用此文本消息
]))
class Connection:
def __init__(self, conn, addr, *args, **kwargs):
self.conn = conn
self.addr = addr
self.isLive = True
self.conn.send(b'Connection accepted by server.')
self.receiveThread = threading.Thread(target=self.recv)
self.receiveThread.start()
self.commandParser = CommandParser()
self.id = None
self.isInitialized = False
def recv(self):
while self.isLive:
try:
data = self.conn.recv(1024)
data = data.decode('utf-8')
commandType, commandData = self.commandParser.parseCommand(data)
self.executeCommand(commandType, commandData)
except BrokenPipeError as e:
self.isLive = False
self.conn.close()
print('Connection closed.')
sys.exit(0)
except ConnectionResetError as e:
print(e)
def executeCommand(self, commandType, commandData):
if commandType == 'quit':
self.sendData('closing')
self.closeConnection()
if commandType == 'init':
self.id = commandData
self.isInitialized = True
print('Connection id initialize to: ', self.id)
def sendData(self, dataString):
data = bytes(dataString, 'utf-8')
try:
self.conn.send(data)
except BrokenPipeError as e:
self.isLive = False
self.conn.close()
except ConnectionResetError as e:
pass
def closeConnection(self):
self.conn.close()
self.isLive = False
async def parse_csl_log(app: GraiaMiraiApplication, group: Group,
_gm: GroupMessage):
await app.sendGroupMessage(
group, MessageChain.create([Plain(tF.csl_log_parsing)]))
CP = CommandParser(_gm, settings.commandSymbol)
fromLs = group.id in [
settings.specialqq.littleskin_main, settings.specialqq.littleskin_cafe
]
try:
_message = aoscPastebin(CP.plain_message, fromLittleSkin=fromLs)
await app.sendGroupMessage(group,
MessageChain.create([Plain(_message)]))
except Exception as e:
await app.sendGroupMessage(group,
MessageChain.create([Plain(repr(e))]))
async def command_view(app: GraiaMiraiApplication, group: Group,
_gm: GroupMessage):
CP = CommandParser(_gm, settings.commandSymbol)
_textureHash = CP.Command.args
if not _textureHash:
await app.sendGroupMessage(
group, MessageChain.create([Plain(tF.view_no_hash_error)]))
elif len(_textureHash) != 64:
await app.sendGroupMessage(
group, MessageChain.create([Plain(tF.view_hash_length_error)]))
else:
_image_message = PlayerProfile.getPreviewByHash(_textureHash)
if _image_message:
await app.sendGroupMessage(group,
MessageChain.create([_image_message]))
else:
await app.sendGroupMessage(
group, MessageChain.create([Plain(tF.view_not_200_error)]))
def __init__(self):
#self.factory = MailListFactory()
self.cp = CommandParser()
self.lists = {}
# --- DATABASE hendeling ---
self.db_path = "lists/"
self.db_name = "database.db"
self.db_conn = None # keeps the connection to the database
self.db_maillists = " maillsits (id INTEGER PRIMERY KEY, name text"
self.db_subsrcibers = " subscribers (id INTEGER PRIMERY KEY," +\
"name text, email text)"
self.db_list_to_subs = " list_to_subscribers (list_id int," +\
" subscribers_id int)"
self.__ensure_database()
# --- End Database handeling ---
self._load_initial_state()
self._init_callbacks()
self._loop()
class MailListProgram():
"""docstring for MailListProgram"""
def __init__(self):
self.factory = MailListFactory()
self.cp = CommandParser()
self.lists = {}
self.db_path = "lists/"
self._load_initial_state()
self._init_callbacks()
self._loop()
def create_list_callback(self, arguments):
name = " ".join(arguments)
maillist = self.factory.create(name)
maillist_adapter = MailListFileAdapter(self.db_path, maillist)
maillist_adapter.save()
self.lists[maillist.get_id()] = (maillist, maillist_adapter)
def add_subscriber_callback(self, arguments):
list_id = int("".join(arguments))
name = input("name>")
email = input("email>")
self.lists[list_id][0].add_subscriber(name, email)
self._notify_save(list_id)
def show_lists_callback(self, arguments):
for list_id in self.lists:
current_list = self.lists[list_id][0]
print("[{}] {}".format(list_id, current_list.get_name()))
def show_list_callback(self, arguments):
list_id = int("".join(arguments))
if list_id in self.lists:
subscribers = self.lists[list_id][0].get_subscribers()
for s in subscribers:
print("{} - {}".format(s[0], s[1]))
else:
print("List with id <{}> was not found".format(list_id))
def exit_callback(self, arguments):
sys.exit(0)
def _load_initial_state(self):
dir_lists = map(basename, glob(self.db_path + "*"))
for list_file in dir_lists:
adapter = MailListFileAdapter(self.db_path)
parsed_list = adapter.load(list_file)
maillist_adapter = MailListFileAdapter(self.db_path, parsed_list)
self.lists[parsed_list.get_id()] = (parsed_list, maillist_adapter)
def _init_callbacks(self):
self.cp.on("create", self.create_list_callback)
self.cp.on("add", self.add_subscriber_callback)
self.cp.on("show_lists", self.show_lists_callback)
self.cp.on("show_list", self.show_list_callback)
self.cp.on("exit", self.exit_callback)
# TODO - implement the rest of the callbacks
def _notify_save(self, list_id):
self.lists[list_id][1].save()
def _loop(self):
while True:
command = input(">")
self.cp.take_command(command)
def setUp(self):
self.cp = CommandParser()
class CommandParserTest(unittest.TestCase):
"""docstring for CommandParserTest"""
def setUp(self):
self.cp = CommandParser()
self.called = False
def test_on_with_single_command(self):
def callback(arguments):
self.called = True
self.assertEqual(0, len(arguments))
self.cp.on("command", callback)
self.cp.take_command("command")
self.assertTrue(self.called)
def test_on_with_full_command(self):
def callback(arguments):
self.called = True
self.assertEqual(["1", "2"], arguments)
self.cp.on("delete_subscriber", callback)
self.cp.take_command("delete_subscriber 1 2")
self.assertTrue(self.called)
def test_on_with_command_not_found(self):
def callback(arguments):
self.called = True
self.cp.on("something", callback)
result = self.cp.take_command("something_else")
self.assertFalse(self.called)
self.assertIsNone(result)
class MailListProgram():
"""docstring for MailListProgram"""
def __init__(self):
self.factory = MailListFactory()
self.cp = CommandParser()
self.lists = {}
self.db_path = "lists/"
self._load_initial_state()
self._init_callbacks()
self._loop()
def create_list_callback(self, arguments):
name = " ".join(arguments)
maillist = self.factory.create(name)
maillist_adapter = MailListFileAdapter(self.db_path, maillist)
maillist_adapter.save()
self.lists[maillist.get_id()] = (maillist, maillist_adapter)
def add_subscriber_callback(self, arguments):
list_id = int("".join(arguments))
name = input("name>")
email = input("email>")
self.lists[list_id][0].add_subscriber(name, email)
self._notify_save(list_id)
def show_lists_callback(self, arguments):
for list_id in self.lists:
current_list = self.lists[list_id][0]
print("[{}] {}".format(list_id,
current_list.get_name()))
def show_list_callback(self, arguments):
list_id = int("".join(arguments))
if list_id in self.lists:
subscribers = self.lists[list_id][0].get_subscribers()
for s in subscribers:
print("{} - {}".format(s[0], s[1]))
else:
print("List with id <{}> was not found".format(list_id))
def exit_callback(self, arguments):
sys.exit(0)
def _load_initial_state(self):
dir_lists = map(basename, glob(self.db_path + "*"))
for list_file in dir_lists:
adapter = MailListFileAdapter(self.db_path)
parsed_list = adapter.load(list_file)
maillist_adapter = MailListFileAdapter(self.db_path, parsed_list)
self.lists[parsed_list.get_id()] = (parsed_list, maillist_adapter)
def _init_callbacks(self):
self.cp.on("create", self.create_list_callback)
self.cp.on("add", self.add_subscriber_callback)
self.cp.on("show_lists", self.show_lists_callback)
self.cp.on("show_list", self.show_list_callback)
self.cp.on("exit", self.exit_callback)
# TODO - implement the rest of the callbacks
def _notify_save(self, list_id):
self.lists[list_id][1].save()
def _loop(self):
while True:
command = input(">")
self.cp.take_command(command)
def __init__(self, database_name):
self.cp = CommandParser()
self.db = DBinterface(database_name)
self.zoos = self.db.update_zoos()
self._init_callbacks()
self._loop()
def __init__(self):
self.modules = {}
self.communicator = None
self.cparser = CommandParser()
class CommandParserTest(unittest.TestCase):
"""docstring for CommandParserTest"""
def setUp(self):
self.cp = CommandParser()
self.called = False
def test_on_with_single_command(self):
def callback(arguments):
self.called = True
self.assertEqual(0, len(arguments))
self.cp.on("command", callback)
self.cp.take_command("command")
self.assertTrue(self.called)
def test_on_with_full_command(self):
def callback(arguments):
self.called = True
self.assertEqual(["1", "2"], arguments)
self.cp.on("delete_subscriber", callback)
self.cp.take_command("delete_subscriber 1 2")
self.assertTrue(self.called)
def test_on_with_command_not_found(self):
def callback(arguments):
self.called = True
self.cp.on("something", callback)
result = self.cp.take_command("something_else")
self.assertFalse(self.called)
self.assertIsNone(result)
def __init__(self):
self.cp = CommandParser()
self.mail_lists = []
self.update_mail_lists(self.mail_lists)
self._init_callbacks()
self._loop()
class MailListProgram():
"""docstring for MailListProgram"""
def __init__(self):
self.factory = MailListFactory()
self.cp = CommandParser()
self.lists = {}
self.db_path = "lists/"
self._load_initial_state()
self._init_callbacks()
self._loop()
def create_list_callback(self, arguments):
if len(str(arguments)) == 4:
print("Invalid listname!")
else:
used_names = self.show_lists_callback("1")
new_args = str(arguments)
if new_args[2:-2] in used_names:
print ("There is already a list with that name!")
else:
conn = sqlite3.connect("mail_list_database.db")
cursor = conn.cursor()
result = cursor.execute('''INSERT INTO maillist(name)
VALUES (?)''', (arguments))
conn.commit()
conn.close()
def add_subscriber_callback(self, arguments):
list_id = arguments[0]
conn = sqlite3.connect("mail_list_database.db")
cursor = conn.cursor()
name = input("name>")
email = input("email>")
result1 = cursor.execute('''SELECT subs_id
FROM subscribers
WHERE name = ? and email = ?''', (name, email))
final_res = cursor.fetchone()
if final_res is None:
print(cursor.fetchone())
result2 = cursor.execute('''INSERT INTO subscribers(name, email)
VALUES(?, ?)''', (name, email))
result3 = cursor.execute('''SELECT subs_id
FROM subscribers
WHERE name = ? and email = ?''', (name, email))
result_from_3rd_query = cursor.fetchone()
res3 = int(result_from_3rd_query[0])
result4 = cursor.execute(''' INSERT INTO maillist_to_subscribers(list_id, subscribesr_id)
VALUES (?, ?)''', (list_id, res3))
else:
result_from_1st_query = final_res
res1 = int(result_from_1st_query[0])
result5 = cursor.execute('''SELECT list_id
FROM maillist_to_subscribers
WHERE subscribesr_id = (?)''', str(res1))
lists = []
for row in result5:
lists.append(int(row[0]))
if int(list_id) in lists:
print ("The subscriber is already in that list")
else:
result6 = cursor.execute('''INSERT INTO maillist_to_subscribers(list_id, subscribesr_id)
VALUES (?,?)''', (list_id, res1) )
conn.commit()
conn.close()
def show_lists_callback(self, want_return=0):
conn = sqlite3.connect("mail_list_database.db")
cursor = conn.cursor()
list_names = []
list_ids = []
result = cursor.execute("SELECT * FROM maillist")
for row in result:
list_ids.append(row[0])
list_names.append(row[1])
conn.close()
the_wish = len(want_return)
if the_wish == 0:
for row in range(0, len(list_ids)):
print("{" + str(list_ids[row]) + "} " + list_names[row])
else:
return(list_names)
def show_list_callback(self, arguments):
conn = sqlite3.connect("mail_list_database.db")
cursor = conn.cursor()
used_names = self.show_lists_callback("1")
integer_argument = int(arguments[0])
if integer_argument > len(used_names):
print ("There is no list with this identifier!")
else:
result = cursor.execute('''SELECT DISTINCT subscribers.name, subscribers.email
FROM subscribers INNER JOIN maillist_to_subscribers ON subscribers.subs_id = maillist_to_subscribers.subscribesr_id
INNER JOIN maillist ON maillist_to_subscribers.list_id = ?''', (arguments))
counter = 1
for row in result:
print("{" + str(counter) + "} " + str(row[0]) + " - " + str(row[1]) )
counter += 1
conn.commit()
conn.close()
def exit_callback(self, arguments):
sys.exit(0)
def _load_initial_state(self):
dir_lists = map(basename, glob(self.db_path + "*"))
for list_file in dir_lists:
adapter = MailListFileAdapter(self.db_path)
parsed_list = adapter.load(list_file)
maillist_adapter = MailListFileAdapter(self.db_path, parsed_list)
self.lists[parsed_list.get_id()] = (parsed_list, maillist_adapter)
def _init_callbacks(self):
self.cp.on("create", self.create_list_callback)
self.cp.on("add", self.add_subscriber_callback)
self.cp.on("show_lists", self.show_lists_callback)
self.cp.on("show_list", self.show_list_callback)
self.cp.on("exit", self.exit_callback)
# TODO - implement the rest of the callbacks
def _notify_save(self, list_id):
self.lists[list_id][1].save()
def _loop(self):
while True:
command = input(">")
self.cp.take_command(command)
def __init__(self, database_name):
self.cp = CommandParser()
self.db = Database(database_name)
self._init_callbacks()
self._loop()
class Store():
"""docstring for Command-line Interface"""
def __init__(self, database_name):
self.cp = CommandParser()
self.db = Database(database_name)
self._init_callbacks()
self._loop()
def callback_import_products_json(self, arguments):
json_filename = " ".join(arguments)
if self.db.import_products_json(json_filename) is True:
return "{} imported.".format(json_filename[:-5])
else:
return "{} could not be imported.".format(json_filename)
def callback_export_products_json(self, arguments):
json_filename = " ".join(arguments)
opened_file = open(json_filename, "w")
opened_file.write(self.db.export_products_json())
opened_file.close()
return "Products exported to {}".format(json_filename)
def callback_unknown_command(self, arguments):
message = ("Error: Unknown Command!",
"Why don't you enter help to see available commands?")
return "\n".join(message)
def callback_list_products(self, arguments):
return self.db.list_products()
def callback_add_product(self, arguments):
name = str(input("name>"))
price_per_kg = str(input("price per kg>"))
quantity_in_kg = str(input("quantity in kg>"))
if self.db.add_product(name, price_per_kg, quantity_in_kg):
return "{} added to products.".format(name)
def callback_delete_product(self, arguments):
product_id = arguments[0]
name = self.db.fetch_product_name(product_id)
if self.db.delete_product(product_id) is True:
return "{} deleted.".format(name)
def callback_update_product(self, arguments):
product_id = arguments[0]
old_name = self.db.fetch_product_name(product_id)
new_name = str(input("name>"))
price_per_kg = str(input("price per kg>"))
quantity_in_kg = str(input("quantity in kg>"))
if self.db.update_product(new_name, price_per_kg,
quantity_in_kg) is True:
return "{} updated to {}.".format(old_name, new_name)
def callback_import_customers_json(self, arguments):
json_filename = " ".join(arguments)
if self.db.import_customers_json(json_filename) is True:
return "Imported customers from json_filename"
def callback_list_customers(self, arguments):
return self.db.list_customers()
def callback_add_customer(self, arguments):
name = input("name>")
kg_bought = input("kg bought>")
money_spent = input("money spent>")
if self.db.add_customer(self, name, kg_bought, money_spent) is True:
return "Added {}.".format(name)
def callback_delete_customer(self, arguments):
customer_id = arguments[0]
if self.db.delete_customer(customer_id) is True:
return "Deleted {}.".format(
self.db.fetch_customer_name(customer_id))
def callback_update_customer(self, arguments):
customer_id = arguments[0]
name = input("name>")
kg_bought = input("kg bought>")
money_spent = input("money spent>")
if self.db.update_customer(self, name, kg_bought, money_spent,
customer_id) is True:
return "Updated {}".format(self.db)
def callback_export_customers_json(self, arguments):
json_filename = " ".join(arguments)
opened_file = open(json_filename, "w")
opened_file.write(self.db.export_customers_json())
opened_file.close()
return "Exported customers to {}".format(json_filename)
def callback_help(self, arguments):
help_message_products = (
"* import_products_json <json_filename> - Adds products from the json file to the database.",
"* list_products - Prints out all products in the following format: \"[id] name - price_per_kg BGN - quantity kg\"",
"* add_product - Prompts for data, needed to add a new product to the database.",
"* delete_product <product_id> - Removes the product matching the product id in the database.",
"* update_product <product_id> - Updates the product data matching the product id in the database.",
"* export_products_json <json_filename> - Exports the products to a json file."
)
help_message_customers = (
"* import_json_customers <json_filename> - Adds customers from the json file to the database.",
"* list_customers - Prints out all customers in the following format: \"[id] name - kg_bought kg - money_spent BGN\"",
"* add_customer - Prompts for data, needed to add a new customer to the database.",
"* delete_customer <customer_id> - Removes the customer matching the customer id in the database.",
"* update_customer <customer_id> - Updates the customer data matching the customer id in the database.",
"* export_customers_json <json_filename> - Exports the customers in the database to a json file."
)
return "\n".join(help_message_products + help_message_customers)
def _init_callbacks(self):
self.cp.on("list_products", self.callback_list_products)
self.cp.on("list_customers", self.callback_list_customers)
self.cp.on("add_product", self.callback_add_product)
self.cp.on("add_customer", self.callback_add_customer)
self.cp.on("update_product", self.callback_update_product)
self.cp.on("update_customer", self.callback_update_customer)
self.cp.on("delete_product", self.callback_delete_product)
self.cp.on("delete_customer", self.callback_delete_customer)
self.cp.on("import_products_json", self.callback_import_products_json)
self.cp.on("import_customers_json",
self.callback_import_customers_json)
self.cp.on("export_products_json", self.callback_export_products_json)
self.cp.on("export_customers_json",
self.callback_export_customers_json)
self.cp.on("help", self.callback_help)
def _loop(self):
while True:
command = input(">")
self.cp.take_command(command)
class CLI():
"""docstring for CLI"""
def __init__(self):
self.cp = CommandParser()
self.fh = FileHandler()
self._init_callbacks()
self._loop()
def callback_create_attendance_file(self, arguments):
if self.fh.create_attendance_file() is True:
return "New file created and loaded: {}".format(
self.fh.get_current_open_file())
elif self.fh.create_attendance_file() is False:
return "You already have a file for today it is: {}".format(
self.fh.get_current_open_file())
def callback_change_current_date(self, arguments):
if self.fh.change_current_date(arguments) is True:
return "Date changed to {}/{}/{}\nCurrent file saved & discarded.\nYou can create or load.".format(
arguments[0], arguments[1], arguments[2])
def callback_add_attendance(self, arguments):
try:
student = "{} {}".format(arguments[0], arguments[1])
except IndexError:
return "Error: Please enter student as FirstName LastName"
if self.fh.is_student_attending(student) is True:
return "{} is already attending!".format(student)
elif self.fh.is_student_attending(student) is False:
if self.fh.add_attendance(student) is True:
return "{} is now attending!".format(student)
elif self.fh.add_attendance(student) is False:
return "Create or load a file before adding!"
elif self.fh.is_student_attending(student) is None:
return "{} is not in our records.".format(student)
def callback_list_files(self, arguments):
return self.fh.list_attendance_files()
def callback_help(self, arguments):
help_message = [
"Available commands are:", "* create", "* change_date", "* add",
"* list", "* load", "* status", "* statistics"
]
return "\n".join(help_message)
def callback_load(self, arguments):
try:
file_id = arguments[0]
except IndexError:
return "Error: No ID given"
if self.fh.load_attendance_file(file_id) is True:
return "Loaded {}".format(self.fh.get_current_open_file())
elif self.fh.load_attendance_file(file_id) is False:
return "Error: Invalid ID. Use list before using load."
def callback_status(self, arguments):
return self.fh.list_attending_students()
def callback_statistics(self, arguments):
return self.fh.get_statistics()
def _init_callbacks(self):
self.cp.on("create", self.callback_create_attendance_file)
self.cp.on("change_date", self.callback_change_current_date)
self.cp.on("add", self.callback_add_attendance)
self.cp.on("list", self.callback_list_files)
self.cp.on("help", self.callback_help)
self.cp.on("load", self.callback_load)
self.cp.on("status", self.callback_status)
self.cp.on("statistics", self.callback_statistics)
def _loop(self):
while True:
command = input("command>")
self.cp.take_command(command)
def __init__(self):
self.cp = CommandParser()
self.fh = FileHandler()
self._init_callbacks()
self._loop()
class Interface():
"""Mail list interface"""
def __init__(self):
self.cp = CommandParser()
self.mail_lists = []
self.update_mail_lists(self.mail_lists)
self._init_callbacks()
self._loop()
def callback_show_lists(self, arguments):
output = []
for i, mail_object in enumerate(self.mail_lists):
output.append("[{}] {}".format(i+1, mail_object._name))
return "\n".join(output)
def callback_show_list(self, arguments):
unique_list_identifier = int(arguments[0]) - 1
try:
return self.mail_lists[unique_list_identifier].show_subscribers()
except IndexError:
return "List with unique identifier {} was not found!".format(unique_list_identifier+1)
def callback_add_subscriber(self, arguments):
unique_list_identifier = arguments[0]
desired_list = self.mail_lists[int(unique_list_identifier) - 1]
name = str(input("name>"))
email = str(input("email>"))
if desired_list.add_subscriber(name, email) is True:
desired_list.save("file")
return "{} was added to {}.".format(name, desired_list._name)
return "Subscriber with email <{}> already exists.".format(email)
def callback_remove_subscriber(self, arguments):
unique_list_identifier = int(arguments[0]) - 1
subscriber_id = int(arguments[1]) - 1
desired_list = self.mail_lists[unique_list_identifier]
subscriber_name = desired_list.get_subscriber_name(subscriber_id)
if desired_list.remove_subscriber(subscriber_name) is True:
desired_list.save("file")
return "<{}> was removed from <{}>.".format(subscriber_name, desired_list._name)
return "Subscriber <{}> was not found in <{}>.".format(subscriber_name, desired_list._name)
def callback_update_subscriber(self, arguments):
unique_list_identifier = int(arguments[0]) - 1
subscriber_id = int(arguments[1]) - 1
desired_list = self.mail_lists[unique_list_identifier]
subscriber_name = desired_list.get_subscriber_name(subscriber_id)
subscriber_email = desired_list.get_subscriber_email(subscriber_id)
print("Updating <{}> - <{}>\nPress Enter if you want the field to remain the same".format(subscriber_name, subscriber_email))
new_name = input("new name>")
new_email = input("new email>")
if new_name == "":
if new_email == "":
return "Nothing to update."
else:
desired_list.update_subscriber(subscriber_name, subscriber_name, new_email)
desired_list.save("file")
return "Updated <{}> - <{}>.".format(subscriber_name, new_email)
elif new_email == "":
if new_name == "":
return "Nothing to update."
else:
desired_list.update_subscriber(subscriber_name, new_name, subscriber_email)
desired_list.save("file")
return "Updated <{}> - <{}>.".format(new_name, subscriber_email)
else:
desired_list.update_subscriber(subscriber_name, new_name, new_email)
desired_list.save("file")
return "Updated <{}> - <{}>.".format(new_name, new_email)
def callback_create_maillist(self, arguments):
list_name = arguments[0]
mail_list = Database(list_name)
self.mail_lists.append(mail_list)
mail_list.save("file")
return "New list <{}> was created.".format(list_name)
def callback_delete_maillist(self, arguments):
unique_list_identifier = int(arguments[0]) - 1
desired_list = self.mail_lists[unique_list_identifier]
if desired_list.remove_list() is True:
return "{} was deleted.".format(desired_list.get_name())
return "You crazy bastard. Stop playing with fire!"
def callback_update_maillist(self, arguments):
unique_list_identifier = int(arguments[0]) - 1
new_list_name = arguments[1]
to_be_deleted_list = self.mail_lists[unique_list_identifier]
old_name = to_be_deleted_list._name
old_subscribers = to_be_deleted_list._subscribers
self.mail_lists.pop(unique_list_identifier)
mail_list = Database(new_list_name)
mail_list._subscribers = old_subscribers
self.mail_lists.append(mail_list)
mail_list.save("file")
remove("./Lists/{}".format(to_be_deleted_list.get_file_name()))
return "Updated <{}> to <{}>".format(old_name, mail_list._name)
def callback_search_by_email(self, arguments):
found_in_lists = []
needle_email = arguments[0]
for maillist_object in self.mail_lists:
if maillist_object.has_subscriber_with_email(needle_email) is True:
found_in_lists.append(maillist_object._name)
return "\n".join(found_in_lists)
def callback_merge_lists(self, arguments):
list_id_a = int(arguments[0]) - 1
list_id_b = int(arguments[1]) - 1
new_list_name = arguments[2]
list_a = self.mail_lists[list_id_a]
list_b = self.mail_lists[list_id_b]
a_subscribers = list_a._subscribers
b_subscribers = list_b._subscribers
a_name = list_a._name
b_name = list_b._name
mail_list = Database(new_list_name)
mail_list._subscribers = dict(a_subscribers, **b_subscribers)
self.mail_lists.append(mail_list)
return "Merged <{}> and <{}> into <{}>".format(a_name, b_name, new_list_name)
def callback_export_json(self, arguments):
unique_list_identifier = int(arguments[0]) - 1
desired_list = self.mail_lists[unique_list_identifier]
desired_list.save("json")
return "Exported <{}> to <{}.json>".format(desired_list.get_name(), desired_list.get_file_name())
def callback_welcome(self):
return "Hello Stranger! This is a cutting-edge, console-based mail-list!\nType help, to see a list of commands."
def callback_help(self, arguments):
help_message = ("Here is a full list of commands:",
"* show_lists - Prints all lists to the screen. Each list is assigned with a unique identifier",
"* show_list <unique_list_identifier> - Prints all people, one person at a line, that are subscribed for the list. The format is: <Name> - <Email>",
"* add <unique_list_identifier> - Starts the procedure for adding a person to a mail list. The program prompts for name and email.",
"* update_subscriber <unique_list_identifier> <unique_name_identifier> - updates the information for the given subscriber in the given list",
"* remove_subscriber <unique_list_identifier> <unique_name_identifier> - Removes the given subscriber from the given list",
"* create <list_name> - Creates a new empty list, with the given name.",
"* update <unique_list_identifier> <new_list_name> - Updates the given list with a new name.",
"* search_email <email> - Performs a search into all lists to see if the given email is present. Shows all lists, where the email was found.",
"* merge_lists <list_identifier_1> <list_identifier_2> <new_list_name> - merges list1 and list2 into a new list, with the given name.",
"* export <unique_list_identifier> - Exports the given list into JSON file, named just like the list. All white spaces are replaced by underscores.",
"* exit - this will quit the program")
return "\n".join(help_message)
def callback_exit(self):
exit("Exiting.")
def update_mail_lists(self, arguments):
for filename in self.fetch_maillists():
opened_file = open(filename, "r")
contents = opened_file.readlines()
filename = filename.split("/")[2]
maillist = Database(filename)
for record in contents:
record = record.split(" - ")
maillist.add_subscriber(record[0], record[1].rstrip())
self.mail_lists.append(maillist)
opened_file.close()
def fetch_maillists(self):
return glob("./Lists/*[!.json]")
def _init_callbacks(self):
print(self.callback_welcome())
self.cp.on("show_lists", self.callback_show_lists)
self.cp.on("show_list", self.callback_show_list)
self.cp.on("add", self.callback_add_subscriber)
self.cp.on("update_subscriber", self.callback_update_subscriber)
self.cp.on("remove_subscriber", self.callback_remove_subscriber)
self.cp.on("create", self.callback_create_maillist)
self.cp.on("update", self.callback_update_maillist)
self.cp.on("search_email", self.callback_search_by_email)
self.cp.on("merge", self.callback_merge_lists)
self.cp.on("export", self.callback_export_json)
self.cp.on("help", self.callback_help)
self.cp.on("exit", self.callback_exit)
def _loop(self):
while True:
command = input(">")
self.cp.take_command(command)
class MailListProgram():
"""docstring for MailListProgram"""
def __init__(self):
#self.factory = MailListFactory()
self.cp = CommandParser()
self.lists = {}
# --- DATABASE hendeling ---
self.db_path = "lists/"
self.db_name = "database.db"
self.db_conn = None # keeps the connection to the database
self.db_maillists = " maillsits (id INTEGER PRIMERY KEY, name text"
self.db_subsrcibers = " subscribers (id INTEGER PRIMERY KEY," +\
"name text, email text)"
self.db_list_to_subs = " list_to_subscribers (list_id int," +\
" subscribers_id int)"
self.__ensure_database()
# --- End Database handeling ---
self._load_initial_state()
self._init_callbacks()
self._loop()
def __ensure_database(self):
self.db_conn = sqlite3.connect(self.db_path + self.db_name)
command = "CREATE TABLE IF NOT EXISTS"
# Lists all the tables
list_of_tables = [self.db_maillist,
self.db_subsrcibers, self.db_list_to_subs]
# Creates all the tables of the database
for table in list_of_tables:
self.db_conn.execute(command + table)
def create_list_callback(self, arguments):
name = " ".join(arguments)
maillist = MailList(-1, name)
maillist_adapter = MailListFileAdapter(self.db_path, maillist)
maillist_adapter.save()
self.lists[maillist.get_id()] = (maillist, maillist_adapter)
def add_subscriber_callback(self, arguments):
list_id = int("".join(arguments))
name = input("name>")
email = input("email>")
self.lists[list_id][0].add_subscriber(name, email)
self._notify_save(list_id)
def show_lists_callback(self, arguments):
for list_id in self.lists:
current_list = self.lists[list_id][0]
print("[{}] {}".format(list_id,
current_list.get_name()))
def show_list_callback(self, arguments):
list_id = int("".join(arguments))
if list_id in self.lists:
subscribers = self.lists[list_id][0].get_subscribers()
for s in subscribers:
print("{} - {}".format(s[0], s[1]))
else:
print("List with id <{}> was not found".format(list_id))
def exit_callback(self, arguments):
sys.exit(0)
def _load_initial_state(self):
dir_lists = map(basename, glob(self.db_path + "*"))
for list_file in dir_lists:
adapter = MailListFileAdapter(self.db_path)
parsed_list = adapter.load(list_file)
maillist_adapter = MailListFileAdapter(self.db_path, parsed_list)
self.lists[parsed_list.get_id()] = (parsed_list, maillist_adapter)
def _init_callbacks(self):
self.cp.on("create", self.create_list_callback)
self.cp.on("add", self.add_subscriber_callback)
self.cp.on("show_lists", self.show_lists_callback)
self.cp.on("show_list", self.show_list_callback)
self.cp.on("exit", self.exit_callback)
# TODO - implement the rest of the callbacks
def _notify_save(self, list_id):
self.lists[list_id][1].save()
def _loop(self):
while True:
command = input(">")
self.cp.take_command(command)
def __init__(self):
self.cp = CommandParser()
self.db = db_interface.DBInterface("mail_lists.db")
self._init_callbacks()
self._loop()
def setUp(self):
self.cp = CommandParser()
self.called = False
class MailListProgram():
"""docstring for MailListProgram"""
def __init__(self):
self.cp = CommandParser()
self.db = db_interface.DBInterface("mail_lists.db")
self._init_callbacks()
self._loop()
def create_list_callback(self, arguments):
name = " ".join(arguments)
if self.db.create_maillist(name) is True:
return "<{}> was created.".format(name)
else:
return "<{}> failed to create.".format(name)
def add_subscriber_callback(self, arguments):
list_id = arguments[0]
name = input("name>")
email = input("email>")
if self.db.add_subscriber(name, email, list_id) is True:
list_name = self.db.fetch_maillist_name_by_id(list_id)["name"]
return "{} added to list {}".format(name, list_name)
else:
return "Failed to add <{}> to list <{}>."
def show_lists_callback(self, arguments):
output_message = []
for dictionary in self.db.fetch_maillists():
string = "[{}] <{}>".format(dictionary["id"], dictionary["name"])
output_message.append(string)
return "\n".join(output_message)
def show_list_callback(self, arguments):
try:
list_id = int("".join(arguments))
except ValueError:
return "Error: Invalid list id."
output_message = []
try:
subscribers = self.db.fetch_subscribers(list_id)
list_name = self.db.fetch_maillist_name_by_id(list_id)["name"]
output_message.append("~~~~~~~<{}>~~~~~~~".format(list_name))
for line in subscribers:
output_message.append("[{}] <{}> - <{}>".format(
line["subscriber_id"], line["name"], line["email"]))
except TypeError:
output_message.append(
"List with id <{}> was not found.".format(list_id))
return "\n".join(output_message)
def delete_mail_list_callback(self, arguments):
maillist_id = " ".join(arguments)
self.db.delete_maillist_by_id(maillist_id)
return "Mail list with id {} was deleted.".format(maillist_id)
def update_mail_list_name_callback(self, arguments):
maillist_id = arguments[0]
arguments.remove(maillist_id)
new_name = " ".join(arguments)
if self.db.update_maillist_name(maillist_id, new_name) is True:
return "Mail list with id {} updated to <{}>.".format(
maillist_id, new_name)
else:
return "Mail list with id {} not found.".format(maillist_id)
def update_subscriber_callback(self, arguments):
list_id = arguments[0]
subscriber_id = arguments[1]
name = str(input("name>"))
email = str(input("email>"))
data = {}
data["name"] = name
data["email"] = email
self.db.update_subscriber(list_id, subscriber_id, data)
return "Updated <{}>.".format(data["name"])
def remove_subscriber_callback(self, arguments):
list_id = arguments[0]
subscriber_id = arguments[1]
if self.db.delete_subscriber(list_id, subscriber_id) is True:
return "{} deleted from {}".format()
def search_email_callback(self, arguments):
email = arguments[0]
found_in_lists = self.db.fetch_maillists_by_subscriber_email(email)
output_message = []
for a_list in found_in_lists:
output_message.append("[{}] {}".format(a_list["id"],
a_list["name"]))
return "\n".join(output_message)
def merge_lists_callback(self, arguments):
list_id_a = arguments[0]
list_id_b = arguments[1]
arguments.remove(list_id_a)
arguments.remove(list_id_b)
new_list_name = " ".join(arguments)
self.db.merge_lists(list_id_a, list_id_b, new_list_name)
return "Merged lists with ids {} and {} to <{}>".format(
list_id_a, list_id_b, new_list_name)
def export_json_callback(self, arguments):
list_id = arguments[0]
json_contents = self.db.export_json(list_id)
list_name = self.db.fetch_maillist_name_by_id(list_id)["name"].replace(
" ", "_")
file_name = "{}.json".format(list_name)
opened_file = open(file_name, "w")
opened_file.write(json_contents)
opened_file.close()
return "{} exported to {}".format(list_name, file_name)
def help_callback(self, arguments):
output_message = (
"Here is a full list of commands:",
"* show_lists - Prints all lists to the screen. Each list is assigned with a unique identifier",
"* show_list <unique_list_identifier> - Prints all people, one person at a line, that are subscribed for the list. The format is: <Name> - <Email>",
"* add <unique_list_identifier> - Starts the procedure for adding a person to a mail list. The program prompts for name and email.",
"* update_subscriber <unique_list_identifier> <unique_name_identifier> - updates the information for the given subscriber in the given list",
"* remove_subscriber <unique_list_identifier> <unique_name_identifier> - Removes the given subscriber from the given list",
"* create <list_name> - Creates a new empty list, with the given name.",
"* update <unique_list_identifier> <new_list_name> - Updates the given list with a new name.",
"* delete <unique_list_identifier> - Deletes the given list from the database.",
"* search_email <email> - Performs a search into all lists to see if the given email is present. Shows all lists, where the email was found.",
"* merge_lists <list_identifier_1> <list_identifier_2> <new_list_name> - merges list1 and list2 into a new list, with the given name.",
"* export <unique_list_identifier> - Exports the given list into JSON file, named just like the list. All white spaces are replaced by underscores.",
"* exit - this will quit the program")
return "\n".join(output_message)
def exit_callback(self, arguments):
exit(0)
def _init_callbacks(self):
self.cp.on("show_lists", self.show_lists_callback)
self.cp.on("show_list", self.show_list_callback)
self.cp.on("add", self.add_subscriber_callback)
self.cp.on("update_subscriber", self.update_subscriber_callback)
self.cp.on("remove_subscriber", self.remove_subscriber_callback)
self.cp.on("delete", self.delete_mail_list_callback)
self.cp.on("create", self.create_list_callback)
self.cp.on("update", self.update_mail_list_name_callback)
self.cp.on("search_email", self.search_email_callback)
self.cp.on("merge_lists", self.merge_lists_callback)
self.cp.on("export_json", self.export_json_callback)
self.cp.on("exit", self.exit_callback)
self.cp.on("help", self.help_callback)
def _loop(self):
while True:
command = input(">")
self.cp.take_command(command)
class CLI():
"""docstring for CLI"""
def __init__(self):
self.cp = CommandParser()
self.fh = FileHandler()
self._init_callbacks()
self._loop()
def callback_take(self, arguments):
try:
name = arguments[0]
price = int(arguments[1])
except IndexError:
return "Error: Give arguments as \"take <name> <price>\""
if self.fh.take_order(name, price) is True:
return "Taking order from {} for {}".format(name, price)
def callback_status(self, arguments):
return self.fh.list_orders()
def callback_save(self, arguments):
if self.fh.save_file() is True:
return "Saved."
def callback_list(self, arguments):
return self.fh.list_files()
def callback_load(self, arguments):
try:
list_id = int(arguments[0]) - 1
except IndexError:
return "Error: Invalid List ID."
if self.fh.load_file(list_id) is None:
return "Use list command before loading."
elif self.fh.load_file(list_id) is False:
return "You have not saved the current order.\nIf you wish to discard it, type load <number> again."
elif self.fh.load_file(list_id) is True:
return "Loaded {}.".format(self.fh.fetch_file_name(list_id))
def callback_history(self, arguments):
return self.fh.fetch_history()
def callback_finish(self, arguments):
return exit()
def callback_help(self, arguments):
help_message = ("Error: Unknown command!", "Try one of the following:",
" take <name> <price>", " status", " save", " list",
" load <number>", " finish")
return "\n".join(help_message)
def _init_callbacks(self):
self.cp.on("take", self.callback_take)
self.cp.on("status", self.callback_status)
self.cp.on("save", self.callback_save)
self.cp.on("list", self.callback_list)
self.cp.on("load", self.callback_load)
self.cp.on("finish", self.callback_finish)
self.cp.on("help", self.callback_help)
self.cp.on("history", self.callback_history)
def _loop(self):
while True:
command = input("command>")
self.cp.take_command(command)
class MailListProgram():
"""docstring for MailListProgram"""
def __init__(self):
self.db_path = "maillist"
self.conn=sqlite3.connect(self.db_path)
self.create_table(self.conn.cursor())
self.factory = MailListDataBaseFactory(self.conn)
self.cp = CommandParser()
self.lists = {}
self._load_initial_state()
self._init_callbacks()
self._loop()
def create_table(self,cursor):
cursor.execute(''' CREATE TABLE IF NOT EXISTS maillist
(maillist_id INTEGER PRIMARY KEY, name text)''')
cursor.execute(''' CREATE TABLE IF NOT EXISTS subscribers
(subscriber_id INTEGER PRIMARY KEY, name text, email text)''')
cursor.execute(''' CREATE TABLE IF NOT EXISTS maillists_to_subscribers
(maillist_id int, subscriber_id int)''')
def create_list_callback(self, arguments):
name = " ".join(arguments)
maillist = self.factory.create(name)
maillist_adapter = MailListDataBaseAdapter(self.db_path,maillist)
maillist_adapter.save()
self.lists[maillist.get_id()] = (maillist, maillist_adapter)
def add_subscriber_callback(self, arguments):
list_id = int("".join(arguments))
if not list_id in self.lists:
print("Id is incorrect, try again.")
else:
name = input("name>")
email = input("email>")
self.lists[list_id][0].add_subscriber(name, email)
#TODO: function which add subscriber into tables
def show_lists_callback(self, arguments):
for list_id in self.lists:
current_list = self.lists[list_id][0]
print("[{}] {}".format(list_id,
current_list.get_name()))
def show_list_callback(self, arguments):
list_id = int("".join(arguments))
if list_id in self.lists:
subscribers = self.lists[list_id][0].get_subscribers()
for s in subscribers:
print("{} - {}".format(s[0], s[1]))
else:
print("List with id <{}> was not found".format(list_id))
def exit_callback(self, arguments):
sys.exit(0)
def _load_initial_state(self):
c=self.conn;
ids_of_maillists=c.execute("SELECT maillist_id FROM maillist").fetchall()
for id in ids_of_maillists:
adapter=MailListDataBaseAdapter("maillist")
maillist=adapter.load(id[0])
self.lists[id[0]]=(maillist,adapter)
def _init_callbacks(self):
self.cp.on("create", self.create_list_callback)
self.cp.on("add", self.add_subscriber_callback)
self.cp.on("show_lists", self.show_lists_callback)
self.cp.on("show_list", self.show_list_callback)
self.cp.on("exit", self.exit_callback)
# TODO - implement the rest of the callbacks
def _loop(self):
while True:
command = input(">")
self.cp.take_command(command)
class ZooSim():
def __init__(self, database_name):
self.cp = CommandParser()
self.db = DBinterface(database_name)
self.zoos = self.db.update_zoos()
self._init_callbacks()
self._loop()
def callback_list_animal_species(self, arguments):
output = []
for i, specie in enumerate(self.db.fetch_species()):
output.append("[{}] {}".format(i+1, specie["species"]))
return "\n".join(output)
def callback_list_zoos(self, arguments):
output_list = []
for i, zoo in enumerate(self.db.get_zoos()):
output_list.append("[{}] <{}> <{}> <${}>".format(i+1, zoo["name"], zoo["capacity"], zoo["budget"]))
return "\n".join(output_list)
def callback_create_zoo(self, arguments):
name = input("name>")
capacity = input("capacity>")
budget = input("budget>")
zoo = self.db.create_zoo(name, capacity, budget)
if zoo is False:
return "Zoo with name <{}> already exists. Try to be more original!".format(name)
self.zoos.append(zoo)
return "Zoo <{}> created.".format(name)
def callback_see_animals(self, arguments):
zoo_id = arguments[0]
try:
desired_zoo = self.zoos[int(zoo_id)-1]
except (ValueError, IndexError):
return "No zoo with id <{}>.".format(zoo_id)
return desired_zoo.see_animals()
def callback_exit(self, arguments):
exit(0)
def callback_add_animal(self, arguments):
zoo_id = int(arguments[0]) - 1
desired_zoo = self.zoos[zoo_id]
zoo_name = desired_zoo.get_name()
species = input("species>")
age = int(input("age>"))
name = input("name>")
gender = input("gender>")
weight = float(input("weight>"))
animal = self.db.create_animal(zoo_name, species, age, name, gender, weight)
if animal is False:
return "Failed to add <{}> the <{}>. He/she already exists!".format(name, species)
if desired_zoo.add_animal(animal) is True:
return "Added <{}> to zoo <{}>".format(name, desired_zoo.get_name())
return "Failed to add <{}> the <{}>. Zoo <{}> is already full!".format(name, species, zoo_name)
def callback_remove_animal(self, arguments):
zoo_id = int(arguments[0]) - 1
animal_id = int(arguments[0]) - 1
desired_zoo = self.zoos[zoo_id]
try:
desired_zoo.remove_animal(animal_id)
except IndexError:
return "Animal with ID <{}>, doesn't exist in Zoo <{}>".format(animal_id, desired_zoo.get_name())
return "Removed animal from zoo <{}>".format(desired_zoo.get_name())
def callback_simulate_time(self, arguments):
zoo_id = int(arguments[0]) - 1
zoo_object = self.zoos[zoo_id]
period_type = arguments[1]
period = int(arguments[2])
simulation = TimeSpanSimulator(zoo_object, period_type, period)
def callback_help(self, arguments):
help_message = ("* list_species - lists known animal species",
"* list_zoos - lists all created zoos",
"* see_animals <zoo_id> - lists all animal from the zoo matching the zoo_id (use list_zoos before hand)",
"* create_zoo - creates a zoo. Science!",
"* accommodate <zoo_id> - accommodates an animal in the zoo matching the zoo_id",
"* move_to_habitat <zoo_id> - releases an animal from the zoo matching the zoo_id",
"* simulate <zoo_id> <period_type> <period> - simulates a time span for the given zoo",
"* exit - exits. Yes, it does.")
return "\n".join(help_message)
def _init_callbacks(self):
self.cp.on("list_species", self.callback_list_animal_species)
self.cp.on("list_zoos", self.callback_list_zoos)
self.cp.on("see_animals", self.callback_see_animals)
self.cp.on("create_zoo", self.callback_create_zoo)
self.cp.on("accommodate", self.callback_add_animal)
self.cp.on("move_to_habitat", self.callback_remove_animal)
self.cp.on("simulate", self.callback_simulate_time)
self.cp.on("help", self.callback_help)
self.cp.on("exit", self.callback_exit)
def _loop(self):
while True:
command = input(">")
self.cp.take_command(command)
class MailListProgram():
"""docstring for MailListProgram"""
def __init__(self):
self.cp = CommandParser()
self.lists = {}
self.db_path = "lists/"
self.adapter = SQLRelationList(self.db_path)
self._load_initial_state()
self._init_callbacks()
self._loop()
def create_list_callback(self, arguments):
name = " ".join(arguments)
maillist = MailList(name)
list_id = self.adapter.sql_mail.save(name)
self.lists[list_id] = maillist
def add_subscriber_callback(self, arguments):
list_id = int("".join(arguments))
name = input("name>")
email = input("email>")
subscriber = Subscriber(name, email)
if self.lists[list_id].add_subscriber(subscriber):
#add subscriber to the database and get subscriber id
subscriber_id = self.adapter.sql_subscriber_table.save(subscriber)
#add the list_id<->subscriber_id relation to the relation table
self.adapter.add_relation(list_id, subscriber_id)
# self._notify_save(list_id)
def show_lists_callback(self, arguments):
for list_id in self.lists:
current_list = self.lists[list_id]
print("[{}] {}".format(list_id,
current_list.get_name()))
def show_list_callback(self, arguments):
list_id = int("".join(arguments))
if list_id in self.lists:
subscribers = self.lists[list_id].get_subscribers()
for s in subscribers:
print("{} - {}".format(s[0], s[1]))
else:
print("List with id <{}> was not found".format(list_id))
def exit_callback(self, arguments):
sys.exit(0)
#load all lists in the database into self.lists
def _load_initial_state(self):
lists = self.adapter.sql_mail.get_lists()
for unparsed_list in lists:
list_id = unparsed_list[0]
list_name = unparsed_list[1]
maillist = MailList(list_name)
#load list subscribers
subscribers = self.adapter.get_subscribers_in_list(list_id)
for subscriber in subscribers:
maillist.subscribers.append(subscriber)
self.lists[list_id] = maillist
def _init_callbacks(self):
self.cp.on("create", self.create_list_callback)
self.cp.on("add", self.add_subscriber_callback)
self.cp.on("show_lists", self.show_lists_callback)
self.cp.on("show_list", self.show_list_callback)
self.cp.on("exit", self.exit_callback)
# TODO - implement the rest of the callbacks
# def _notify_save(self, list_id):
# self.lists[list_id].save()
def _loop(self):
while True:
command = input(">")
self.cp.take_command(command)
def __init__(self):
self.modules = {}
self.communicator = None
self.services = None
self.cparser = CommandParser()
class MailListProgram():
"""docstring for MailListProgram"""
def __init__(self):
self.factory = MailListFactory()
self.cp = CommandParser()
self.lists = []
self._load_initial_state()
self._init_callbacks()
self._loop()
def create_list_callback(self, arguments):
name = " ".join(arguments)
maillist = self.factory.create(name)
maillist_adapter = MailListFileAdapter(self.db_path, maillist)
maillist_adapter.save()
self.lists.append(maillist.get_name())
print(self.lists)
def add_subscriber_callback(self, arguments):
list_id = int("".join(arguments))
name = input("name>")
email = input("email>")
subscriber = Subscriber(name, email)
subscriber.save()
self.db_path = sqlite3.connect("maillist.db")
self.cursor = self.db_path.cursor()
self.cursor.execute("""CREATE TABLE IF NOT EXISTS relations
(list_id, subscriber_id)""")
query = ("""INSERT INTO relations(list_id, subscriber_id)
VALUES(?, ?)""")
data = [list_id, subscriber.id]
print(data)
self.cursor.execute(query, data)
self.db_path.commit()
self.db_path.close()
def show_lists_callback(self, arguments):
for list_id in self.lists:
current_list = self.lists[list_id][0]
print("[{}] {}".format(list_id,
current_list.get_name()))
def show_list_callback(self, arguments):
list_id = int("".join(arguments))
if list_id in self.lists:
subscribers = self.lists[list_id][0].get_subscribers()
for s in subscribers:
print("{} - {}".format(s[0], s[1]))
else:
print("List with id <{}> was not found".format(list_id))
def exit_callback(self, arguments):
sys.exit(0)
def _load_initial_state(self):
if os.path.isfile("maillist.db"):
self.db_path = sqlite3.connect("maillist.db")
self.cursor = self.db_path.cursor()
lists_data = self.cursor.execute("""SELECT name FROM Lists""")
for list in lists_data:
self.lists.append(list[0])
def _init_callbacks(self):
self.cp.on("create", self.create_list_callback)
self.cp.on("add", self.add_subscriber_callback)
self.cp.on("show_lists", self.show_lists_callback)
self.cp.on("show_list", self.show_list_callback)
self.cp.on("exit", self.exit_callback)
# TODO - implement the rest of the callbacks
def _notify_save(self, list_id):
self.lists[list_id - 1].save()
def _loop(self):
while True:
command = input(">")
self.cp.take_command(command)
def setUp(self):
self.cp = CommandParser()
self.called = False
class TestCommandParser(unittest.TestCase):
def setUp(self):
self.cp = CommandParser()
def testSayCommand(self):
self.assertEqual('PRIVMS #dickler :hello to everyone', self.cp.parse('say #dickler hello to everyone'))
