Cleanup

.pylintrc

 [MESSAGES CONTROL]
-disable=bad-indentation, invalid-name
+disable=bad-indentation, bare-except, global-statement, invalid-name
 
 [FORMAT]
 

search.py

+"""Script for searching email messages in a collection of zip files of raw email message files."""
 import argparse
-import re
+import os
 import platform
+import re
 import subprocess
+import sys
+from email.message import EmailMessage
+from email.parser import BytesParser
+from email.utils import parsedate
+from enum import Enum
 from tempfile import TemporaryDirectory
 from typing import List, Optional, Union
-from enum import Enum
-from email.utils import parsedate
-from email.parser import BytesParser
-from email.message import EmailMessage
 from zipfile import ZipFile
-import sys
-import os
 
 class BooleanOperator(Enum):
 	"""Boolean combinatory operator enum."""
 		self.subject: Optional[str] = None
 		self.before: Optional[List[int]] = None
 		self.after: Optional[List[int]] = None
-		self.raw: bool = False
 
 args: Options = Options()
 message_filter: Filter = None
 	filename += '.eml'
 	return filename
 
-def walk_directory(path: str) -> None:
+def walk_directory(directory: str) -> None:
 	"""Spiders a directory looking for subdirectories and email zip archives."""
 	global zip_count
-	for f in os.listdir(path):
-		full_path = path + os.sep + f
+	for f in os.listdir(directory):
+		full_path = directory + os.sep + f
 		if f.lower().endswith('.zip'):
 			zip_count += 1
 			process_zip_file(full_path)
 
 def process_zip_file(zip_path: str) -> None:
 	"""Processes a zip file of email messages."""
-	global zip_result_count
+	global parser, zip_result_count
 	print('Searching ' + zip_path + '...')
 	zip_result_count = 0
-	with ZipFile(zip_path, mode='r') as zip:
-		for entry in zip.filelist:
+	with ZipFile(zip_path, mode='r') as z:
+		for entry in z.filelist:
 			if entry.is_dir():
 				continue
-			data = zip.read(entry)
+			data = z.read(entry)
 			parser = BytesParser()
 			try:
 				email = parser.parsebytes(data)
 
 def search_content(email: EmailMessage) -> None:
 	"""Processes an email message in a zip file."""
-	global result_count, zip_result_count
 	if message_filter.matches(email):
 		save_message(email)
 
 def search_raw_content(raw_bytes: bytes) -> None:
-	global result_count, zip_result_count
+	"""Searches an unparsed email message."""
 	encodings = [ 'ascii', 'iso-8859-1', 'utf-8' ]
 	content = None
 	for encoding in encodings:
 def parse_arguments():
 	"""Parses command-line arguments to `args`."""
 	global args, parser
-	# TODO: Revisit raw mode and how unparseable emails should be handled
 	parser = argparse.ArgumentParser(
 		prog='search.py',
 		description='Searches a directory of zipped email messages. ' + \
 			'Messages are assumed to be stored one per file within the zip files (Maildir format). ' + \
-			'Input directories are searched recursively for any zip files contained within.',
-		epilog='If raw mode is enabled, any messages that cannot be decoded ' + \
-			'will be searched as raw text.'
+			'Input directories are searched recursively for any zip files contained within.'
 	)
 	parser.add_argument(
 		'keywords',
 		metavar='YYYY-MM-DD',
 		help='date to search on or before'
 	)
-	parser.add_argument(
-		'-r', '--raw',
-		default=False,
-		action='store_true',
-		help='allows searching unparseable messages as raw text'
-	)
 	args = parser.parse_args()
 
 def validate_arguments():
 	"""Validate and parse special field types"""
-	global args
 	args.keywords = args.keywords[0]  # no idea why it nests it 2D
 	if args.before is not None:
 		m = re.match('^([0-9]{4})-([0-9]{2})-([0-9]{2})$', args.before)
 		if m is None:
 			parser.error('after date must be in YYYY-MM-DD format (e.g. 2015-03-28)')
 		args.after = [ int(m.group(1)), int(m.group(2)), int(m.group(3)) ]
-	if args.raw:
-		if getattr(args, 'from') is not None or \
-			getattr(args, 'to') is not None or \
-			args.subject is not None or \
-			args.before is not None or \
-			args.after is not None:
-			print('Warning: Cannot search header fields in raw mode. Ignoring.', file=sys.stderr)
 	if args.dir is None:
 		args.dir = [ '.' ]
 	else:
 			parser.error(f'output path \'{args.output}\' does not exist or is not a directory')
 
 def construct_filter():
+	"""Sets `filter` from parsed command line arguments."""
 	global message_filter
 	criteria: List[Filter] = []
 	keyword_filters = []
 		if len(k) > 0:
 			keyword_filters.append(BodyKeywordFilter(k, case_sensitive=args.casesensitive))
 	if len(keyword_filters) > 0:
-		criteria.append(BooleanFilter(BooleanOperator.or_op if args.any else BooleanOperator.and_op, keyword_filters))
+		op = BooleanOperator.or_op if args.any else BooleanOperator.and_op
+		criteria.append(BooleanFilter(op, keyword_filters))
 	if getattr(args, 'from') is not None:
 		criteria.append(HeaderFilter('from', getattr(args, 'from')))
 	if getattr(args, 'to') is not None: