def _format_date(self, date):
"""
Convert struct_time to QIF date format (MM/DD/YYYY).
Parameters
----------
date : time.struct_time
The date of the transaction.
Returns
-------
str
String date in the format of "MM/DD/YYYY".
Raises
------
TypeError
If date is not a struct_time.
ValueError
If a date value is out of range.
OverflowError
If a value in the tuple is too large to be stored in a C long.
"""
try:
return time.strftime("%m/%d/%Y", date)
except (ValueError, TypeError, OverflowError) as err:
msg = "date ({0}) cannot be converted ".format(date) + "to MM/DD/YYYY "
exception.add_message(err, msg)
raise
def parse(self, string):
"""
Returns
-------
powl.actiondata.TransactionData
Contains data to perform a transaction action.
Raises
------
ValueError
If amount is not a float.
If a value for TransactionData is missing.
"""
data = actiondata.TransactionData()
params = string.split(self._TOKEN_FLAG)
for param in params:
if re.match(self._TOKEN_DEBIT, param):
data.debit = re.sub(self._TOKEN_DEBIT, "", param)
data.debit = data.debit.strip()
elif re.match(self._TOKEN_CREDIT, param):
data.credit = re.sub(self._TOKEN_CREDIT, "", param)
data.credit = data.credit.strip()
elif re.match(self._TOKEN_AMOUNT, param):
data.amount = re.sub(self._TOKEN_AMOUNT, "", param)
data.amount = data.amount.strip()
elif re.match(self._TOKEN_MEMO, param):
data.memo = re.sub(self._TOKEN_MEMO, "", param)
data.memo = data.memo.replace('"', "")
data.memo = data.memo.strip()
if not data.debit:
msg = "debit is missing from ({0})".format(string)
err = exception.create(ValueError, msg)
raise err
if not data.credit:
msg = "credit is missing from ({0})".format(string)
err = exception.create(ValueError, msg)
raise err
if not data.amount:
msg = "amount is missing from ({0})".format(string)
err = exception.create(ValueError, msg)
raise err
if not data.memo:
msg = "memo is missing from ({0})".format(string)
err = exception.create(ValueError, msg)
raise err
try:
float(data.amount)
except ValueError as err:
message = "amount ({0}) is not a number".format(data.amount)
exception.add_message(err, message)
raise
return data
def test__add__sanity(self):
"""
Test that added message by string can be retrieved.
"""
error_message = "error message"
err = Exception()
exception.add_message(err, error_message)
actual = exception.get_message(err)
self.assertEqual(error_message, actual)
def parse(self, string):
"""
Returns
-------
powl.actiondata.BodyCompositionData
Contains data to perform a body composition action.
Raises
------
ValueError
If mass or fat percentage is not a float.
If a value for BodyCompositionData is missing.
"""
data = actiondata.BodyCompositionData()
params = string.split(self._TOKEN_FLAG)
for param in params:
if re.match(self._TOKEN_MASS, param):
data.mass = re.sub(self._TOKEN_MASS, "", param)
data.mass = data.mass.strip()
elif re.match(self._TOKEN_FAT, param):
data.fat_percentage = re.sub(self._TOKEN_FAT, "", param)
data.fat_percentage = data.fat_percentage.strip()
if not data.mass:
msg = "mass was not parsed from ({0})".format(string)
err = exception.create(ValueError, msg)
raise err
if not data.fat_percentage:
msg = "fat percentage was not parsed " + "from ({0})".format(string)
err = exception.create(ValueError, msg)
raise err
try:
float(data.mass)
except ValueError as err:
msg = "mass ({0}) is not a number".format(data.mass)
exception.add_message(err, msg)
raise
try:
float(data.fat_percentage)
except ValueError as err:
msg = "fat percentage ({0}) ".format(data.fat_percentage) + "is not a number"
exception.add_message(err, msg)
raise
return data
def login(self, user, password):
self._assert_connected()
self._assert_not_empty(user, _ERRMSG_EMPTY_USER)
self._assert_not_empty(password, _ERRMSG_EMPTY_PASSWORD)
try:
self._imap.login(user, password)
except imaplib.IMAP4.error as err:
if ("Invalid credentials" in str(err) or
"AUTHENTICATIONFAILED" in str(err)):
errmsg = _ERRMSG_INVALID_CREDENTIALS
exception.add_message(err, errmsg)
raise
self._select_mailbox()
self._logged_in = True
def connect(self, server):
self._assert_not_empty(server, _ERRMSG_EMPTY_SERVER)
try:
self._imap = imaplib.IMAP4_SSL(server)
except socket.timeout as err:
errmsg = _ERRMSG_TIMEOUT.format(server)
exception.add_message(err, errmsg)
raise
except IOError as err:
if err.errno == socket.EAI_NONAME:
errmsg = _ERRMSG_SERVER_NOT_FOUND.format(server)
elif err.errno == socket.errno.ENETUNREACH:
errmsg = _ERRMSG_SERVER_NOT_FOUND.format(server)
else:
errmsg = _ERRMSG_CONNECT_UNKNOWN.format(server)
exception.add_message(err, errmsg)
raise
def do_action(self, action_type, action_data, action_date):
"""
Do the specified action.
Parameters
----------
action_type : powl.actiontype
The type of action to do.
action_data : str
Formatted string containing action data.
action_date : time.struct_time
Date associated with the action.
"""
try:
action = self._action_type_to_action_map[action_type]
except KeyError as err:
message = "action type ({0}) is unknown".format(action_type)
exception.add_message(err, message)
raise
else:
action.do(action_data, action_date)
def parse(self, string):
"""
Returns
-------
powl.actiondata.BodyCompositionData
Contains data to perform a body composition action.
Raises
------
ValueError
If mass or fat percentage is not a float.
If a value for BodyCompositionData is missing.
"""
data = actiondata.BodyCompositionData()
params = re.split(self._DELIMITER, string, self._MAX_SPLITS)
if len(params) < self._NUM_PARAMS:
msg = "not enough arguments from ({0})".format(string)
err = exception.create(ValueError, msg)
raise err
mass = params[self._POSITION_MASS]
fat_percentage = params[self._POSITION_FAT]
try:
data.mass = float(mass)
except ValueError as err:
msg = "mass ({0}) is not a number".format(mass)
exception.add_message(err, msg)
raise
try:
data.fat_percentage = float(fat_percentage)
except ValueError as err:
msg = "fat percentage ({0}) ".format(fat_percentage) + "is not a number"
exception.add_message(err, msg)
raise
return data
def _format_amount(self, debit, amount):
"""
Convert amount to QIF format based on debit.
Parameters
----------
debit : str
Account key for the debit of a transaction.
amount : str or float
Amount of the transaction.
Returns
-------
str
Formatted amount to use in QIF file.
Raises
------
ValueError
If amount cannot be converted to a float.
KeyError
If debit key is not an account.
"""
try:
formatted_amount = "{0:.2f}".format(float(amount))
except ValueError as err:
msg = "amount ({0}) cannot be converted to float".format(amount)
exception.add_message(err, msg)
raise
if debit in self._expenses:
# Amount should be negative.
return "-" + formatted_amount
elif debit in self._accounts:
return formatted_amount
else:
msg = "account key ({0}) does not exist".format(debit)
err = exception.create(KeyError, msg)
raise err
def parse(self, item):
"""
Returns
-------
tuple of powl.actiontype and str
The action type and a string containing data for the action.
Raises
------
KeyError
If the action_key is not in the action map.
ValueError
If a valid action was not parsed.
"""
action_key, data = item.split(self._DELIMITER, 1)
try:
action_type = actiontype.ACTION_MAP[action_key]
except KeyError as err:
msg = "action key ({0}) is unknown".format(action_key)
exception.add_message(err, msg)
raise
else:
return action_type, data
