-
Notifications
You must be signed in to change notification settings - Fork 1
/
simple_addr.py
487 lines (409 loc) · 15.3 KB
/
simple_addr.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
simple_addr.py
simple_addr is a simplest possible address book, designed to work well with a
mutt query_command for good ol' TUI email. The goal is simplicity over
features.
License Info
------------
This is released under the MIT License.
Copyright (c) 2019 David Lowry-Duda <david@lowryduda.com>.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""
import argparse
import os
import sys
import email
import re
VERSION = "0.0.1"
# TODO add repr
class AddressItem:
"""
Representation of a single address entry.
Mutt expects responses in the form
david@lowryduda.com <TAB> David Lowry-Duda <TAB> OtherInfo <TAB> [other]
and mutt ignores [other stuff] (including any further tabbed data). Each
AddressItem must contain an `email_address` and `name`. Optionally it can
contain `otherinfo`, and `extrainfo`. Any `otherinfo` will be visible in
mutt, but `extrainfo` will not be visible in mutt.
"""
def __init__(
self,
_email_address=None,
_name=None,
_otherinfo="",
_extrainfo="",
**kwargs
):
"""
Set email_address, name, otherinfo, and extrainfo. Any additional
kwargs are also stored in (key, value) pairs.
If `_email_address` or `_name` is not defined, raise an Exception.
"""
self.email_address = _email_address
self.name = _name
self.otherinfo = _otherinfo
self.extrainfo = _extrainfo
self.misc = kwargs.items()
self.validate()
def __str__(self):
"""
A tab-separated single-line representation for the file. A line is of
the form
address\tname\totherinfo[\textrainfo][\tmisc1][\tmisc2]
"""
ret = "{address}\t{name}\t{otherinfo}".format(
address = self.email_address,
name = self.name,
otherinfo = self.otherinfo
)
if self.extrainfo:
ret = ret + "\t" + self.extrainfo
if self.misc:
ret = ret + self.format_misc()
return ret
def format_misc(self):
"""
Gives a string representation for the misc part fo the address. This is
of the form
\t(key1, val1)\t(key2, val2)...
"""
if not self.misc:
return ""
ret = ""
for key, val in self.misc:
ret = ret + "\t({key}, {val})".format(key=key, val=val)
return ret
def validate(self):
"""
If email_address of name is not defined, raise an Exception.
If more than 8 misc attributes are given, raise an Exception.
"""
if (self.email_address is None) or (self.name is None):
raise IOError(
"Invalid address detected. Address and name must be given."
)
if len(self.misc) > 8:
raise IOError(
"Invalid address detected. Too many misc descriptors."
)
def _addressitem_from_line(line):
"""
Convert a raw text line to an AddressItem.
The structure of a line is defined in the definition for AddressItem.
"""
sline = line.split("\t")
if len(sline) < 2:
raise IOError("Error parsing address from line. Malformed data.")
address = sline[0]
name = sline[1]
if len(sline) > 2:
otherinfo = sline[2]
else:
otherinfo = ""
if len(sline) > 3:
extrainfo = sline[3]
else:
extrainfo = ""
if len(sline) > 4:
raw_misc = sline[4:]
misc = _raw_misc_to_dict(raw_misc)
else:
misc = {}
return AddressItem(
_email_address=address,
_name=name,
_otherinfo=otherinfo,
_extrainfo=extrainfo,
**misc
)
def _addressitem_from_email(emailstr):
"""
Extract name and email address from 'From' field in an email, and convert to
an AddressItem.
"""
if len(emailstr) < 2:
raise IOError("Error parsing email. Aborting.")
_name, _email = extract_sender(emailstr)
return AddressItem(_email_address=_email, _name=_name)
def _raw_misc_to_dict(raw):
"""
Converts text-form of misc to a dictionary.
misc will be stored in the form ["(key1, val1)", "(key2, val2)",...]
"""
ret = {}
for elem in raw:
key, _, val = elem.partition(',')
key = key.lstrip("(").strip()
val = val[:-1].strip()
ret[key] = val
return ret
class AddressList:
"""
Representation of all addresses.
AddressList stores a list of tuples of AddressItems. AddressList is read
from a file if it exists, and is otherwise empty.
"""
#TODO add repr
def __init__(self, filedir='.', filename='.address_list'):
"""
Read addresses from address_list in `filename` if they exist.
"""
self.addresses = []
self.filedir = os.path.expanduser(filedir)
self.filename = filename
path = os.path.join(os.path.realpath(self.filedir), self.filename)
if os.path.isdir(path):
raise IOError("Invalid address_list file. File is a directory.")
if os.path.exists(path):
with open(path, 'r') as address_file:
lines = [line.strip() for line in address_file if line]
self.addresses = list(map(_addressitem_from_line, lines))
def __getitem__(self, name):
"""
Retrieves address containing `name`.
If more than one is found, raise an exception. To search, use the search
method.
"""
matches = list(
filter(lambda aitem: name in aitem.name, self.addresses)
)
if not matches:
raise KeyError("Name {} does not appear in addresses.".format(name))
if len(matches) > 1:
raise IOError("{} appears multiple times.".format(name))
return matches[0]
def add_address(self, **kwargs):
"""
Add address with given data to addresses.
AddressItem is responsible for validation of input.
"""
addressitem = AddressItem(**kwargs)
self.addresses.append(addressitem)
# TODO check uniqueness of email addresses
def add_addressitem(self, addressitem):
"""
Add addressitem to addresses.
"""
self.addresses.append(addressitem)
def _unique_address(self, **kwargs):
"""
Finds unique address with input, or raises exception.
Used in remove_address, edit_address, and __getitem__.
(Or rather it will be, once it's written).
"""
pass
def remove_address(self):
pass
def edit_address(self):
pass
def print(self, sublist=None):
"""
Prints addresses (or just those in `sublist` if given) to terminal.
"""
addresses = self.addresses
total_len = len(addresses)
if sublist is not None:
addresses = sublist
print("In address-list ... {} entries ... {} matching".format(
total_len,
len(addresses)
))
for aitem in addresses:
print(aitem)
def search(self, **kwargs):
"""
Returns list of addresses satisfying search criteria in **kwargs.
For each (key, val) in kwargs, search will require that `val` be in the
`key` attribute of each AddressItem. Searches are strict --- all
criteria must pass for an item to be returned.
"""
ret = self.addresses
for key, val in kwargs.items():
# Slightly odd syntax setting default values for key and val so that
# v and k are not leaky cell variables.
ret = list(
filter(lambda aitem, v=val, k=key: v in getattr(aitem, k, ""), ret)
)
if not ret:
raise KeyError("No addresses found matching criteria.")
return ret
def mutt_search(self, term):
"""
Returns list of address containing search term `term`. This is
meant to be used by mutt.
Addresses containing `term` in the name, email, otherinfo, or extrainfo
fields are returned. Note that extrainfo isn't displayed in mutt itself,
allowing a somewhat invisible search.
"""
attrs = ("email_address", "name", "otherinfo", "extrainfo")
ret = list(
filter(lambda aitem: any(
term in getattr(aitem, attr, "") for attr in attrs
), self.addresses)
)
return ret
def write(self):
"""
Saves addressfile.
"""
path = os.path.join(os.path.realpath(self.filedir), self.filename)
if os.path.isdir(path):
raise IOError("Invalid address file. File is a directory.")
if self.addresses:
with open(path, 'w') as addressfile:
for addressitem in self.addresses:
addressfile.write(str(addressitem) + "\n")
def _build_parser():
"""
Create CLI.
"""
usage = "Usage: %(prog)s [-dir DIR] [-file FILE] [options] [EXPRESSION]"
epilog = (
"Author: David Lowry-Duda <david@lowryduda.com>."
"\nPlease report any bugs to "
"https://github.com/davidlowryduda/simple_addr.py"
)
parser = argparse.ArgumentParser(usage=usage, epilog=epilog)
parser.add_argument("expr", nargs='*', metavar="EXPRESSION")
actions = parser.add_argument_group(
'Actions',
(
"If no actions are specified, then all addresses matching "
"EXPRESSION will be returned."
)
)
actions.add_argument("-a", "--add",
dest="add",
action="store_true", default=False,
help=(
"add address given by EXPRESSION. EXPRESSION should "
"be of the form 'user@email.com\tname\totherinfo', "
"or of the form 'user@email.com' 'name' 'other info', "
"where each argument is given in a separate field."
))
# actions.add_argument("-I", "--interactive-add",
# dest="interactive_add",
# action="store_true", default=False,
# help="Initialize an interactive script to add an address.")
actions.add_argument("-v", "--version",
dest="print_version",
action="store_true", default=False,
help="Print version and quit.")
config = parser.add_argument_group("Configuration Options")
config.add_argument("-d", "--dir",
dest="filedir", default=".",
help="Use address-list in DIR",
metavar="DIR")
config.add_argument("-f", "--file",
dest="filename", default=".address_list",
help="Use address-list FILE", metavar="FILE")
mutt = parser.add_argument_group("Mutt Integration")
mutt.add_argument("--mutt-add",
dest="add_from_email",
action="store_true", default=False,
help=(
"parse and extract sender from STDIN. "
"STDIN should be a complete email, including "
"headers. The 'From' field in the header is used "
"for the extraction."
))
return parser
def extract_sender(emailstr):
"""
Extracts name and email of sender from given email. Returns (name, email).
Parenthetical comments in the name or email are removed.
"""
msg = email.message_from_string(emailstr)
sender = msg['From']
if sender is None:
raise IOError("Parsing email failed. Aborting.")
if "(" in emailstr:
sender = remove_comments_from_sender(sender)
if "<" not in sender:
raise KeyError("Parsing email sender failed. No address found.")
_name, _, _email = sender.partition("<")
_name = _name.strip()
_email = _email.rstrip(">").strip()
return _name, _email
def remove_comments_from_sender(instring):
"""
Remove parenthetical comments from email name and sender.
Did you know that
david (the bomb) lowry-duda <myemail@(stupid)place.com>
is valid in emails? Boo! Note that comments can contain escaped parentheses,
which this does not check for. If someone with such an email is messaging
you, consider replacing that person with a better person.
"""
## regex explanation
#
# \( # match left paren
# [^\(] # followed by anything that's not a left paren
# *? # a non-greedy number of times
# \) # followed by right paren
parens_re = re.compile("\([^\(]*?\)")
instring = parens_re.sub('', instring)
if "(" in instring:
return remove_comments_from_sender(instring)
return instring
def print_version():
"""
Print version and exit.
"""
output = (
"simple_addr.py {VERSION}\n"
"Copyright 2019 David Lowry-Duda.\n"
"Licence: MIT License <https://opensource.org/licenses/MIT>.\n"
"This is permissive free software: you are free to change and redistribute it.\n"
"There is NO WARRANTY, to the extent permitted by law.\n\n"
"Written by David Lowry-Duda."
).format(VERSION=VERSION)
print(output)
def main(input_args=None):
"""
Main entry point.
"""
args = _build_parser().parse_args(args=input_args)
addresslist = AddressList(filedir=args.filedir, filename=args.filename)
if args.print_version:
print_version()
elif args.add:
expression = '\t'.join(args.expr).strip()
addressitem = _addressitem_from_line(expression)
addresslist.add_addressitem(addressitem)
addresslist.write()
elif args.add_from_email:
expression = ''.join(sys.stdin.readlines())
#expression = ''.join(args.expr).strip()
addressitem = _addressitem_from_email(expression)
addresslist.add_addressitem(addressitem)
addresslist.write()
else:
search_expr = ''.join(args.expr).strip()
if not search_expr:
addresslist.print()
else:
sublist = addresslist.mutt_search(search_expr)
addresslist.print(sublist)
sys.exit(0)
if __name__ == "__main__":
try:
main()
except Exception as e:
print(e)
sys.exit(1)