##// END OF EJS Templates
re-write columnize, with intermediate step....
Matthias BUSSONNIER -
Show More
@@ -1,115 +1,140 b''
1 # encoding: utf-8
1 # encoding: utf-8
2 """Tests for IPython.utils.text"""
2 """Tests for IPython.utils.text"""
3
3
4 #-----------------------------------------------------------------------------
4 #-----------------------------------------------------------------------------
5 # Copyright (C) 2011 The IPython Development Team
5 # Copyright (C) 2011 The IPython Development Team
6 #
6 #
7 # Distributed under the terms of the BSD License. The full license is in
7 # Distributed under the terms of the BSD License. The full license is in
8 # the file COPYING, distributed as part of this software.
8 # the file COPYING, distributed as part of this software.
9 #-----------------------------------------------------------------------------
9 #-----------------------------------------------------------------------------
10
10
11 #-----------------------------------------------------------------------------
11 #-----------------------------------------------------------------------------
12 # Imports
12 # Imports
13 #-----------------------------------------------------------------------------
13 #-----------------------------------------------------------------------------
14
14
15 import os
15 import os
16 import math
16 import math
17 import random
17
18
18 import nose.tools as nt
19 import nose.tools as nt
19
20
20 from nose import with_setup
21 from nose import with_setup
21
22
22 from IPython.testing import decorators as dec
23 from IPython.testing import decorators as dec
23 from IPython.utils import text
24 from IPython.utils import text
24
25
25 #-----------------------------------------------------------------------------
26 #-----------------------------------------------------------------------------
26 # Globals
27 # Globals
27 #-----------------------------------------------------------------------------
28 #-----------------------------------------------------------------------------
28
29
29 def test_columnize():
30 def test_columnize():
30 """Basic columnize tests."""
31 """Basic columnize tests."""
31 size = 5
32 size = 5
32 items = [l*size for l in 'abc']
33 items = [l*size for l in 'abc']
33 out = text.columnize(items, displaywidth=80)
34 out = text.columnize(items, displaywidth=80)
34 nt.assert_equals(out, 'aaaaa bbbbb ccccc\n')
35 nt.assert_equals(out, 'aaaaa bbbbb ccccc\n')
35 out = text.columnize(items, displaywidth=10)
36 out = text.columnize(items, displaywidth=12)
36 nt.assert_equals(out, 'aaaaa ccccc\nbbbbb\n')
37 nt.assert_equals(out, 'aaaaa ccccc\nbbbbb\n')
37
38 out = text.columnize(items, displaywidth=10)
39 nt.assert_equals(out, 'aaaaa\nbbbbb\nccccc\n')
40
41 def test_columnize_random():
42 """Test with random input to hopfully catch edge case """
43 for nitems in [random.randint(2,70) for i in range(2,20)]:
44 displaywidth = random.randint(20,200)
45 rand_len = [random.randint(2,displaywidth) for i in range(nitems)]
46 items = ['x'*l for l in rand_len]
47 out = text.columnize(items, displaywidth=displaywidth)
48 longer_line = max([len(x) for x in out.split('\n')])
49 longer_element = max(rand_len)
50 if longer_line > displaywidth:
51 print "Columnize displayed something lager than displaywidth : %s " % longer_line
52 print "longer element : %s " % longer_element
53 print "displaywidth : %s " % displaywidth
54 print "number of element : %s " % nitems
55 print "size of each element :\n %s" % rand_len
56 assert False
57
58 def test_columnize_medium():
59 """Test with inputs than shouldn't be wider tahn 80 """
60 size = 40
61 items = [l*size for l in 'abc']
62 out = text.columnize(items, displaywidth=80)
63 nt.assert_equals(out, '\n'.join(items+['']))
38
64
39 def test_columnize_long():
65 def test_columnize_long():
40 """Test columnize with inputs longer than the display window"""
66 """Test columnize with inputs longer than the display window"""
41 text.columnize(['a'*81, 'b'*81], displaywidth=80)
42 size = 11
67 size = 11
43 items = [l*size for l in 'abc']
68 items = [l*size for l in 'abc']
44 out = text.columnize(items, displaywidth=size-1)
69 out = text.columnize(items, displaywidth=size-1)
45 nt.assert_equals(out, '\n'.join(items+['']))
70 nt.assert_equals(out, '\n'.join(items+['']))
46
71
47 def eval_formatter_check(f):
72 def eval_formatter_check(f):
48 ns = dict(n=12, pi=math.pi, stuff='hello there', os=os, u=u"cafΓ©", b="cafΓ©")
73 ns = dict(n=12, pi=math.pi, stuff='hello there', os=os, u=u"cafΓ©", b="cafΓ©")
49 s = f.format("{n} {n//4} {stuff.split()[0]}", **ns)
74 s = f.format("{n} {n//4} {stuff.split()[0]}", **ns)
50 nt.assert_equals(s, "12 3 hello")
75 nt.assert_equals(s, "12 3 hello")
51 s = f.format(' '.join(['{n//%i}'%i for i in range(1,8)]), **ns)
76 s = f.format(' '.join(['{n//%i}'%i for i in range(1,8)]), **ns)
52 nt.assert_equals(s, "12 6 4 3 2 2 1")
77 nt.assert_equals(s, "12 6 4 3 2 2 1")
53 s = f.format('{[n//i for i in range(1,8)]}', **ns)
78 s = f.format('{[n//i for i in range(1,8)]}', **ns)
54 nt.assert_equals(s, "[12, 6, 4, 3, 2, 2, 1]")
79 nt.assert_equals(s, "[12, 6, 4, 3, 2, 2, 1]")
55 s = f.format("{stuff!s}", **ns)
80 s = f.format("{stuff!s}", **ns)
56 nt.assert_equals(s, ns['stuff'])
81 nt.assert_equals(s, ns['stuff'])
57 s = f.format("{stuff!r}", **ns)
82 s = f.format("{stuff!r}", **ns)
58 nt.assert_equals(s, repr(ns['stuff']))
83 nt.assert_equals(s, repr(ns['stuff']))
59
84
60 # Check with unicode:
85 # Check with unicode:
61 s = f.format("{u}", **ns)
86 s = f.format("{u}", **ns)
62 nt.assert_equals(s, ns['u'])
87 nt.assert_equals(s, ns['u'])
63 # This decodes in a platform dependent manner, but it shouldn't error out
88 # This decodes in a platform dependent manner, but it shouldn't error out
64 s = f.format("{b}", **ns)
89 s = f.format("{b}", **ns)
65
90
66 nt.assert_raises(NameError, f.format, '{dne}', **ns)
91 nt.assert_raises(NameError, f.format, '{dne}', **ns)
67
92
68 def eval_formatter_slicing_check(f):
93 def eval_formatter_slicing_check(f):
69 ns = dict(n=12, pi=math.pi, stuff='hello there', os=os)
94 ns = dict(n=12, pi=math.pi, stuff='hello there', os=os)
70 s = f.format(" {stuff.split()[:]} ", **ns)
95 s = f.format(" {stuff.split()[:]} ", **ns)
71 nt.assert_equals(s, " ['hello', 'there'] ")
96 nt.assert_equals(s, " ['hello', 'there'] ")
72 s = f.format(" {stuff.split()[::-1]} ", **ns)
97 s = f.format(" {stuff.split()[::-1]} ", **ns)
73 nt.assert_equals(s, " ['there', 'hello'] ")
98 nt.assert_equals(s, " ['there', 'hello'] ")
74 s = f.format("{stuff[::2]}", **ns)
99 s = f.format("{stuff[::2]}", **ns)
75 nt.assert_equals(s, ns['stuff'][::2])
100 nt.assert_equals(s, ns['stuff'][::2])
76
101
77 nt.assert_raises(SyntaxError, f.format, "{n:x}", **ns)
102 nt.assert_raises(SyntaxError, f.format, "{n:x}", **ns)
78
103
79 def eval_formatter_no_slicing_check(f):
104 def eval_formatter_no_slicing_check(f):
80 ns = dict(n=12, pi=math.pi, stuff='hello there', os=os)
105 ns = dict(n=12, pi=math.pi, stuff='hello there', os=os)
81
106
82 s = f.format('{n:x} {pi**2:+f}', **ns)
107 s = f.format('{n:x} {pi**2:+f}', **ns)
83 nt.assert_equals(s, "c +9.869604")
108 nt.assert_equals(s, "c +9.869604")
84
109
85 s = f.format('{stuff[slice(1,4)]}', **ns)
110 s = f.format('{stuff[slice(1,4)]}', **ns)
86 nt.assert_equals(s, 'ell')
111 nt.assert_equals(s, 'ell')
87
112
88 nt.assert_raises(SyntaxError, f.format, "{a[:]}")
113 nt.assert_raises(SyntaxError, f.format, "{a[:]}")
89
114
90 def test_eval_formatter():
115 def test_eval_formatter():
91 f = text.EvalFormatter()
116 f = text.EvalFormatter()
92 eval_formatter_check(f)
117 eval_formatter_check(f)
93 eval_formatter_no_slicing_check(f)
118 eval_formatter_no_slicing_check(f)
94
119
95 def test_full_eval_formatter():
120 def test_full_eval_formatter():
96 f = text.FullEvalFormatter()
121 f = text.FullEvalFormatter()
97 eval_formatter_check(f)
122 eval_formatter_check(f)
98 eval_formatter_slicing_check(f)
123 eval_formatter_slicing_check(f)
99
124
100 def test_dollar_formatter():
125 def test_dollar_formatter():
101 f = text.DollarFormatter()
126 f = text.DollarFormatter()
102 eval_formatter_check(f)
127 eval_formatter_check(f)
103 eval_formatter_slicing_check(f)
128 eval_formatter_slicing_check(f)
104
129
105 ns = dict(n=12, pi=math.pi, stuff='hello there', os=os)
130 ns = dict(n=12, pi=math.pi, stuff='hello there', os=os)
106 s = f.format("$n", **ns)
131 s = f.format("$n", **ns)
107 nt.assert_equals(s, "12")
132 nt.assert_equals(s, "12")
108 s = f.format("$n.real", **ns)
133 s = f.format("$n.real", **ns)
109 nt.assert_equals(s, "12")
134 nt.assert_equals(s, "12")
110 s = f.format("$n/{stuff[:5]}", **ns)
135 s = f.format("$n/{stuff[:5]}", **ns)
111 nt.assert_equals(s, "12/hello")
136 nt.assert_equals(s, "12/hello")
112 s = f.format("$n $$HOME", **ns)
137 s = f.format("$n $$HOME", **ns)
113 nt.assert_equals(s, "12 $HOME")
138 nt.assert_equals(s, "12 $HOME")
114 s = f.format("${foo}", foo="HOME")
139 s = f.format("${foo}", foo="HOME")
115 nt.assert_equals(s, "$HOME")
140 nt.assert_equals(s, "$HOME")
@@ -1,736 +1,728 b''
1 # encoding: utf-8
1 # encoding: utf-8
2 """
2 """
3 Utilities for working with strings and text.
3 Utilities for working with strings and text.
4 """
4 """
5
5
6 #-----------------------------------------------------------------------------
6 #-----------------------------------------------------------------------------
7 # Copyright (C) 2008-2011 The IPython Development Team
7 # Copyright (C) 2008-2011 The IPython Development Team
8 #
8 #
9 # Distributed under the terms of the BSD License. The full license is in
9 # Distributed under the terms of the BSD License. The full license is in
10 # the file COPYING, distributed as part of this software.
10 # the file COPYING, distributed as part of this software.
11 #-----------------------------------------------------------------------------
11 #-----------------------------------------------------------------------------
12
12
13 #-----------------------------------------------------------------------------
13 #-----------------------------------------------------------------------------
14 # Imports
14 # Imports
15 #-----------------------------------------------------------------------------
15 #-----------------------------------------------------------------------------
16
16
17 import __main__
17 import __main__
18
18
19 import os
19 import os
20 import re
20 import re
21 import shutil
21 import shutil
22 import sys
22 import sys
23 import textwrap
23 import textwrap
24 from string import Formatter
24 from string import Formatter
25
25
26 from IPython.external.path import path
26 from IPython.external.path import path
27 from IPython.testing.skipdoctest import skip_doctest_py3
27 from IPython.testing.skipdoctest import skip_doctest_py3
28 from IPython.utils import py3compat
28 from IPython.utils import py3compat
29 from IPython.utils.io import nlprint
29 from IPython.utils.io import nlprint
30 from IPython.utils.data import flatten
30 from IPython.utils.data import flatten
31
31
32 #-----------------------------------------------------------------------------
32 #-----------------------------------------------------------------------------
33 # Code
33 # Code
34 #-----------------------------------------------------------------------------
34 #-----------------------------------------------------------------------------
35
35
36 def unquote_ends(istr):
36 def unquote_ends(istr):
37 """Remove a single pair of quotes from the endpoints of a string."""
37 """Remove a single pair of quotes from the endpoints of a string."""
38
38
39 if not istr:
39 if not istr:
40 return istr
40 return istr
41 if (istr[0]=="'" and istr[-1]=="'") or \
41 if (istr[0]=="'" and istr[-1]=="'") or \
42 (istr[0]=='"' and istr[-1]=='"'):
42 (istr[0]=='"' and istr[-1]=='"'):
43 return istr[1:-1]
43 return istr[1:-1]
44 else:
44 else:
45 return istr
45 return istr
46
46
47
47
48 class LSString(str):
48 class LSString(str):
49 """String derivative with a special access attributes.
49 """String derivative with a special access attributes.
50
50
51 These are normal strings, but with the special attributes:
51 These are normal strings, but with the special attributes:
52
52
53 .l (or .list) : value as list (split on newlines).
53 .l (or .list) : value as list (split on newlines).
54 .n (or .nlstr): original value (the string itself).
54 .n (or .nlstr): original value (the string itself).
55 .s (or .spstr): value as whitespace-separated string.
55 .s (or .spstr): value as whitespace-separated string.
56 .p (or .paths): list of path objects
56 .p (or .paths): list of path objects
57
57
58 Any values which require transformations are computed only once and
58 Any values which require transformations are computed only once and
59 cached.
59 cached.
60
60
61 Such strings are very useful to efficiently interact with the shell, which
61 Such strings are very useful to efficiently interact with the shell, which
62 typically only understands whitespace-separated options for commands."""
62 typically only understands whitespace-separated options for commands."""
63
63
64 def get_list(self):
64 def get_list(self):
65 try:
65 try:
66 return self.__list
66 return self.__list
67 except AttributeError:
67 except AttributeError:
68 self.__list = self.split('\n')
68 self.__list = self.split('\n')
69 return self.__list
69 return self.__list
70
70
71 l = list = property(get_list)
71 l = list = property(get_list)
72
72
73 def get_spstr(self):
73 def get_spstr(self):
74 try:
74 try:
75 return self.__spstr
75 return self.__spstr
76 except AttributeError:
76 except AttributeError:
77 self.__spstr = self.replace('\n',' ')
77 self.__spstr = self.replace('\n',' ')
78 return self.__spstr
78 return self.__spstr
79
79
80 s = spstr = property(get_spstr)
80 s = spstr = property(get_spstr)
81
81
82 def get_nlstr(self):
82 def get_nlstr(self):
83 return self
83 return self
84
84
85 n = nlstr = property(get_nlstr)
85 n = nlstr = property(get_nlstr)
86
86
87 def get_paths(self):
87 def get_paths(self):
88 try:
88 try:
89 return self.__paths
89 return self.__paths
90 except AttributeError:
90 except AttributeError:
91 self.__paths = [path(p) for p in self.split('\n') if os.path.exists(p)]
91 self.__paths = [path(p) for p in self.split('\n') if os.path.exists(p)]
92 return self.__paths
92 return self.__paths
93
93
94 p = paths = property(get_paths)
94 p = paths = property(get_paths)
95
95
96 # FIXME: We need to reimplement type specific displayhook and then add this
96 # FIXME: We need to reimplement type specific displayhook and then add this
97 # back as a custom printer. This should also be moved outside utils into the
97 # back as a custom printer. This should also be moved outside utils into the
98 # core.
98 # core.
99
99
100 # def print_lsstring(arg):
100 # def print_lsstring(arg):
101 # """ Prettier (non-repr-like) and more informative printer for LSString """
101 # """ Prettier (non-repr-like) and more informative printer for LSString """
102 # print "LSString (.p, .n, .l, .s available). Value:"
102 # print "LSString (.p, .n, .l, .s available). Value:"
103 # print arg
103 # print arg
104 #
104 #
105 #
105 #
106 # print_lsstring = result_display.when_type(LSString)(print_lsstring)
106 # print_lsstring = result_display.when_type(LSString)(print_lsstring)
107
107
108
108
109 class SList(list):
109 class SList(list):
110 """List derivative with a special access attributes.
110 """List derivative with a special access attributes.
111
111
112 These are normal lists, but with the special attributes:
112 These are normal lists, but with the special attributes:
113
113
114 .l (or .list) : value as list (the list itself).
114 .l (or .list) : value as list (the list itself).
115 .n (or .nlstr): value as a string, joined on newlines.
115 .n (or .nlstr): value as a string, joined on newlines.
116 .s (or .spstr): value as a string, joined on spaces.
116 .s (or .spstr): value as a string, joined on spaces.
117 .p (or .paths): list of path objects
117 .p (or .paths): list of path objects
118
118
119 Any values which require transformations are computed only once and
119 Any values which require transformations are computed only once and
120 cached."""
120 cached."""
121
121
122 def get_list(self):
122 def get_list(self):
123 return self
123 return self
124
124
125 l = list = property(get_list)
125 l = list = property(get_list)
126
126
127 def get_spstr(self):
127 def get_spstr(self):
128 try:
128 try:
129 return self.__spstr
129 return self.__spstr
130 except AttributeError:
130 except AttributeError:
131 self.__spstr = ' '.join(self)
131 self.__spstr = ' '.join(self)
132 return self.__spstr
132 return self.__spstr
133
133
134 s = spstr = property(get_spstr)
134 s = spstr = property(get_spstr)
135
135
136 def get_nlstr(self):
136 def get_nlstr(self):
137 try:
137 try:
138 return self.__nlstr
138 return self.__nlstr
139 except AttributeError:
139 except AttributeError:
140 self.__nlstr = '\n'.join(self)
140 self.__nlstr = '\n'.join(self)
141 return self.__nlstr
141 return self.__nlstr
142
142
143 n = nlstr = property(get_nlstr)
143 n = nlstr = property(get_nlstr)
144
144
145 def get_paths(self):
145 def get_paths(self):
146 try:
146 try:
147 return self.__paths
147 return self.__paths
148 except AttributeError:
148 except AttributeError:
149 self.__paths = [path(p) for p in self if os.path.exists(p)]
149 self.__paths = [path(p) for p in self if os.path.exists(p)]
150 return self.__paths
150 return self.__paths
151
151
152 p = paths = property(get_paths)
152 p = paths = property(get_paths)
153
153
154 def grep(self, pattern, prune = False, field = None):
154 def grep(self, pattern, prune = False, field = None):
155 """ Return all strings matching 'pattern' (a regex or callable)
155 """ Return all strings matching 'pattern' (a regex or callable)
156
156
157 This is case-insensitive. If prune is true, return all items
157 This is case-insensitive. If prune is true, return all items
158 NOT matching the pattern.
158 NOT matching the pattern.
159
159
160 If field is specified, the match must occur in the specified
160 If field is specified, the match must occur in the specified
161 whitespace-separated field.
161 whitespace-separated field.
162
162
163 Examples::
163 Examples::
164
164
165 a.grep( lambda x: x.startswith('C') )
165 a.grep( lambda x: x.startswith('C') )
166 a.grep('Cha.*log', prune=1)
166 a.grep('Cha.*log', prune=1)
167 a.grep('chm', field=-1)
167 a.grep('chm', field=-1)
168 """
168 """
169
169
170 def match_target(s):
170 def match_target(s):
171 if field is None:
171 if field is None:
172 return s
172 return s
173 parts = s.split()
173 parts = s.split()
174 try:
174 try:
175 tgt = parts[field]
175 tgt = parts[field]
176 return tgt
176 return tgt
177 except IndexError:
177 except IndexError:
178 return ""
178 return ""
179
179
180 if isinstance(pattern, basestring):
180 if isinstance(pattern, basestring):
181 pred = lambda x : re.search(pattern, x, re.IGNORECASE)
181 pred = lambda x : re.search(pattern, x, re.IGNORECASE)
182 else:
182 else:
183 pred = pattern
183 pred = pattern
184 if not prune:
184 if not prune:
185 return SList([el for el in self if pred(match_target(el))])
185 return SList([el for el in self if pred(match_target(el))])
186 else:
186 else:
187 return SList([el for el in self if not pred(match_target(el))])
187 return SList([el for el in self if not pred(match_target(el))])
188
188
189 def fields(self, *fields):
189 def fields(self, *fields):
190 """ Collect whitespace-separated fields from string list
190 """ Collect whitespace-separated fields from string list
191
191
192 Allows quick awk-like usage of string lists.
192 Allows quick awk-like usage of string lists.
193
193
194 Example data (in var a, created by 'a = !ls -l')::
194 Example data (in var a, created by 'a = !ls -l')::
195 -rwxrwxrwx 1 ville None 18 Dec 14 2006 ChangeLog
195 -rwxrwxrwx 1 ville None 18 Dec 14 2006 ChangeLog
196 drwxrwxrwx+ 6 ville None 0 Oct 24 18:05 IPython
196 drwxrwxrwx+ 6 ville None 0 Oct 24 18:05 IPython
197
197
198 a.fields(0) is ['-rwxrwxrwx', 'drwxrwxrwx+']
198 a.fields(0) is ['-rwxrwxrwx', 'drwxrwxrwx+']
199 a.fields(1,0) is ['1 -rwxrwxrwx', '6 drwxrwxrwx+']
199 a.fields(1,0) is ['1 -rwxrwxrwx', '6 drwxrwxrwx+']
200 (note the joining by space).
200 (note the joining by space).
201 a.fields(-1) is ['ChangeLog', 'IPython']
201 a.fields(-1) is ['ChangeLog', 'IPython']
202
202
203 IndexErrors are ignored.
203 IndexErrors are ignored.
204
204
205 Without args, fields() just split()'s the strings.
205 Without args, fields() just split()'s the strings.
206 """
206 """
207 if len(fields) == 0:
207 if len(fields) == 0:
208 return [el.split() for el in self]
208 return [el.split() for el in self]
209
209
210 res = SList()
210 res = SList()
211 for el in [f.split() for f in self]:
211 for el in [f.split() for f in self]:
212 lineparts = []
212 lineparts = []
213
213
214 for fd in fields:
214 for fd in fields:
215 try:
215 try:
216 lineparts.append(el[fd])
216 lineparts.append(el[fd])
217 except IndexError:
217 except IndexError:
218 pass
218 pass
219 if lineparts:
219 if lineparts:
220 res.append(" ".join(lineparts))
220 res.append(" ".join(lineparts))
221
221
222 return res
222 return res
223
223
224 def sort(self,field= None, nums = False):
224 def sort(self,field= None, nums = False):
225 """ sort by specified fields (see fields())
225 """ sort by specified fields (see fields())
226
226
227 Example::
227 Example::
228 a.sort(1, nums = True)
228 a.sort(1, nums = True)
229
229
230 Sorts a by second field, in numerical order (so that 21 > 3)
230 Sorts a by second field, in numerical order (so that 21 > 3)
231
231
232 """
232 """
233
233
234 #decorate, sort, undecorate
234 #decorate, sort, undecorate
235 if field is not None:
235 if field is not None:
236 dsu = [[SList([line]).fields(field), line] for line in self]
236 dsu = [[SList([line]).fields(field), line] for line in self]
237 else:
237 else:
238 dsu = [[line, line] for line in self]
238 dsu = [[line, line] for line in self]
239 if nums:
239 if nums:
240 for i in range(len(dsu)):
240 for i in range(len(dsu)):
241 numstr = "".join([ch for ch in dsu[i][0] if ch.isdigit()])
241 numstr = "".join([ch for ch in dsu[i][0] if ch.isdigit()])
242 try:
242 try:
243 n = int(numstr)
243 n = int(numstr)
244 except ValueError:
244 except ValueError:
245 n = 0;
245 n = 0;
246 dsu[i][0] = n
246 dsu[i][0] = n
247
247
248
248
249 dsu.sort()
249 dsu.sort()
250 return SList([t[1] for t in dsu])
250 return SList([t[1] for t in dsu])
251
251
252
252
253 # FIXME: We need to reimplement type specific displayhook and then add this
253 # FIXME: We need to reimplement type specific displayhook and then add this
254 # back as a custom printer. This should also be moved outside utils into the
254 # back as a custom printer. This should also be moved outside utils into the
255 # core.
255 # core.
256
256
257 # def print_slist(arg):
257 # def print_slist(arg):
258 # """ Prettier (non-repr-like) and more informative printer for SList """
258 # """ Prettier (non-repr-like) and more informative printer for SList """
259 # print "SList (.p, .n, .l, .s, .grep(), .fields(), sort() available):"
259 # print "SList (.p, .n, .l, .s, .grep(), .fields(), sort() available):"
260 # if hasattr(arg, 'hideonce') and arg.hideonce:
260 # if hasattr(arg, 'hideonce') and arg.hideonce:
261 # arg.hideonce = False
261 # arg.hideonce = False
262 # return
262 # return
263 #
263 #
264 # nlprint(arg)
264 # nlprint(arg)
265 #
265 #
266 # print_slist = result_display.when_type(SList)(print_slist)
266 # print_slist = result_display.when_type(SList)(print_slist)
267
267
268
268
269 def esc_quotes(strng):
269 def esc_quotes(strng):
270 """Return the input string with single and double quotes escaped out"""
270 """Return the input string with single and double quotes escaped out"""
271
271
272 return strng.replace('"','\\"').replace("'","\\'")
272 return strng.replace('"','\\"').replace("'","\\'")
273
273
274
274
275 def qw(words,flat=0,sep=None,maxsplit=-1):
275 def qw(words,flat=0,sep=None,maxsplit=-1):
276 """Similar to Perl's qw() operator, but with some more options.
276 """Similar to Perl's qw() operator, but with some more options.
277
277
278 qw(words,flat=0,sep=' ',maxsplit=-1) -> words.split(sep,maxsplit)
278 qw(words,flat=0,sep=' ',maxsplit=-1) -> words.split(sep,maxsplit)
279
279
280 words can also be a list itself, and with flat=1, the output will be
280 words can also be a list itself, and with flat=1, the output will be
281 recursively flattened.
281 recursively flattened.
282
282
283 Examples:
283 Examples:
284
284
285 >>> qw('1 2')
285 >>> qw('1 2')
286 ['1', '2']
286 ['1', '2']
287
287
288 >>> qw(['a b','1 2',['m n','p q']])
288 >>> qw(['a b','1 2',['m n','p q']])
289 [['a', 'b'], ['1', '2'], [['m', 'n'], ['p', 'q']]]
289 [['a', 'b'], ['1', '2'], [['m', 'n'], ['p', 'q']]]
290
290
291 >>> qw(['a b','1 2',['m n','p q']],flat=1)
291 >>> qw(['a b','1 2',['m n','p q']],flat=1)
292 ['a', 'b', '1', '2', 'm', 'n', 'p', 'q']
292 ['a', 'b', '1', '2', 'm', 'n', 'p', 'q']
293 """
293 """
294
294
295 if isinstance(words, basestring):
295 if isinstance(words, basestring):
296 return [word.strip() for word in words.split(sep,maxsplit)
296 return [word.strip() for word in words.split(sep,maxsplit)
297 if word and not word.isspace() ]
297 if word and not word.isspace() ]
298 if flat:
298 if flat:
299 return flatten(map(qw,words,[1]*len(words)))
299 return flatten(map(qw,words,[1]*len(words)))
300 return map(qw,words)
300 return map(qw,words)
301
301
302
302
303 def qwflat(words,sep=None,maxsplit=-1):
303 def qwflat(words,sep=None,maxsplit=-1):
304 """Calls qw(words) in flat mode. It's just a convenient shorthand."""
304 """Calls qw(words) in flat mode. It's just a convenient shorthand."""
305 return qw(words,1,sep,maxsplit)
305 return qw(words,1,sep,maxsplit)
306
306
307
307
308 def qw_lol(indata):
308 def qw_lol(indata):
309 """qw_lol('a b') -> [['a','b']],
309 """qw_lol('a b') -> [['a','b']],
310 otherwise it's just a call to qw().
310 otherwise it's just a call to qw().
311
311
312 We need this to make sure the modules_some keys *always* end up as a
312 We need this to make sure the modules_some keys *always* end up as a
313 list of lists."""
313 list of lists."""
314
314
315 if isinstance(indata, basestring):
315 if isinstance(indata, basestring):
316 return [qw(indata)]
316 return [qw(indata)]
317 else:
317 else:
318 return qw(indata)
318 return qw(indata)
319
319
320
320
321 def grep(pat,list,case=1):
321 def grep(pat,list,case=1):
322 """Simple minded grep-like function.
322 """Simple minded grep-like function.
323 grep(pat,list) returns occurrences of pat in list, None on failure.
323 grep(pat,list) returns occurrences of pat in list, None on failure.
324
324
325 It only does simple string matching, with no support for regexps. Use the
325 It only does simple string matching, with no support for regexps. Use the
326 option case=0 for case-insensitive matching."""
326 option case=0 for case-insensitive matching."""
327
327
328 # This is pretty crude. At least it should implement copying only references
328 # This is pretty crude. At least it should implement copying only references
329 # to the original data in case it's big. Now it copies the data for output.
329 # to the original data in case it's big. Now it copies the data for output.
330 out=[]
330 out=[]
331 if case:
331 if case:
332 for term in list:
332 for term in list:
333 if term.find(pat)>-1: out.append(term)
333 if term.find(pat)>-1: out.append(term)
334 else:
334 else:
335 lpat=pat.lower()
335 lpat=pat.lower()
336 for term in list:
336 for term in list:
337 if term.lower().find(lpat)>-1: out.append(term)
337 if term.lower().find(lpat)>-1: out.append(term)
338
338
339 if len(out): return out
339 if len(out): return out
340 else: return None
340 else: return None
341
341
342
342
343 def dgrep(pat,*opts):
343 def dgrep(pat,*opts):
344 """Return grep() on dir()+dir(__builtins__).
344 """Return grep() on dir()+dir(__builtins__).
345
345
346 A very common use of grep() when working interactively."""
346 A very common use of grep() when working interactively."""
347
347
348 return grep(pat,dir(__main__)+dir(__main__.__builtins__),*opts)
348 return grep(pat,dir(__main__)+dir(__main__.__builtins__),*opts)
349
349
350
350
351 def idgrep(pat):
351 def idgrep(pat):
352 """Case-insensitive dgrep()"""
352 """Case-insensitive dgrep()"""
353
353
354 return dgrep(pat,0)
354 return dgrep(pat,0)
355
355
356
356
357 def igrep(pat,list):
357 def igrep(pat,list):
358 """Synonym for case-insensitive grep."""
358 """Synonym for case-insensitive grep."""
359
359
360 return grep(pat,list,case=0)
360 return grep(pat,list,case=0)
361
361
362
362
363 def indent(instr,nspaces=4, ntabs=0, flatten=False):
363 def indent(instr,nspaces=4, ntabs=0, flatten=False):
364 """Indent a string a given number of spaces or tabstops.
364 """Indent a string a given number of spaces or tabstops.
365
365
366 indent(str,nspaces=4,ntabs=0) -> indent str by ntabs+nspaces.
366 indent(str,nspaces=4,ntabs=0) -> indent str by ntabs+nspaces.
367
367
368 Parameters
368 Parameters
369 ----------
369 ----------
370
370
371 instr : basestring
371 instr : basestring
372 The string to be indented.
372 The string to be indented.
373 nspaces : int (default: 4)
373 nspaces : int (default: 4)
374 The number of spaces to be indented.
374 The number of spaces to be indented.
375 ntabs : int (default: 0)
375 ntabs : int (default: 0)
376 The number of tabs to be indented.
376 The number of tabs to be indented.
377 flatten : bool (default: False)
377 flatten : bool (default: False)
378 Whether to scrub existing indentation. If True, all lines will be
378 Whether to scrub existing indentation. If True, all lines will be
379 aligned to the same indentation. If False, existing indentation will
379 aligned to the same indentation. If False, existing indentation will
380 be strictly increased.
380 be strictly increased.
381
381
382 Returns
382 Returns
383 -------
383 -------
384
384
385 str|unicode : string indented by ntabs and nspaces.
385 str|unicode : string indented by ntabs and nspaces.
386
386
387 """
387 """
388 if instr is None:
388 if instr is None:
389 return
389 return
390 ind = '\t'*ntabs+' '*nspaces
390 ind = '\t'*ntabs+' '*nspaces
391 if flatten:
391 if flatten:
392 pat = re.compile(r'^\s*', re.MULTILINE)
392 pat = re.compile(r'^\s*', re.MULTILINE)
393 else:
393 else:
394 pat = re.compile(r'^', re.MULTILINE)
394 pat = re.compile(r'^', re.MULTILINE)
395 outstr = re.sub(pat, ind, instr)
395 outstr = re.sub(pat, ind, instr)
396 if outstr.endswith(os.linesep+ind):
396 if outstr.endswith(os.linesep+ind):
397 return outstr[:-len(ind)]
397 return outstr[:-len(ind)]
398 else:
398 else:
399 return outstr
399 return outstr
400
400
401 def native_line_ends(filename,backup=1):
401 def native_line_ends(filename,backup=1):
402 """Convert (in-place) a file to line-ends native to the current OS.
402 """Convert (in-place) a file to line-ends native to the current OS.
403
403
404 If the optional backup argument is given as false, no backup of the
404 If the optional backup argument is given as false, no backup of the
405 original file is left. """
405 original file is left. """
406
406
407 backup_suffixes = {'posix':'~','dos':'.bak','nt':'.bak','mac':'.bak'}
407 backup_suffixes = {'posix':'~','dos':'.bak','nt':'.bak','mac':'.bak'}
408
408
409 bak_filename = filename + backup_suffixes[os.name]
409 bak_filename = filename + backup_suffixes[os.name]
410
410
411 original = open(filename).read()
411 original = open(filename).read()
412 shutil.copy2(filename,bak_filename)
412 shutil.copy2(filename,bak_filename)
413 try:
413 try:
414 new = open(filename,'wb')
414 new = open(filename,'wb')
415 new.write(os.linesep.join(original.splitlines()))
415 new.write(os.linesep.join(original.splitlines()))
416 new.write(os.linesep) # ALWAYS put an eol at the end of the file
416 new.write(os.linesep) # ALWAYS put an eol at the end of the file
417 new.close()
417 new.close()
418 except:
418 except:
419 os.rename(bak_filename,filename)
419 os.rename(bak_filename,filename)
420 if not backup:
420 if not backup:
421 try:
421 try:
422 os.remove(bak_filename)
422 os.remove(bak_filename)
423 except:
423 except:
424 pass
424 pass
425
425
426
426
427 def list_strings(arg):
427 def list_strings(arg):
428 """Always return a list of strings, given a string or list of strings
428 """Always return a list of strings, given a string or list of strings
429 as input.
429 as input.
430
430
431 :Examples:
431 :Examples:
432
432
433 In [7]: list_strings('A single string')
433 In [7]: list_strings('A single string')
434 Out[7]: ['A single string']
434 Out[7]: ['A single string']
435
435
436 In [8]: list_strings(['A single string in a list'])
436 In [8]: list_strings(['A single string in a list'])
437 Out[8]: ['A single string in a list']
437 Out[8]: ['A single string in a list']
438
438
439 In [9]: list_strings(['A','list','of','strings'])
439 In [9]: list_strings(['A','list','of','strings'])
440 Out[9]: ['A', 'list', 'of', 'strings']
440 Out[9]: ['A', 'list', 'of', 'strings']
441 """
441 """
442
442
443 if isinstance(arg,basestring): return [arg]
443 if isinstance(arg,basestring): return [arg]
444 else: return arg
444 else: return arg
445
445
446
446
447 def marquee(txt='',width=78,mark='*'):
447 def marquee(txt='',width=78,mark='*'):
448 """Return the input string centered in a 'marquee'.
448 """Return the input string centered in a 'marquee'.
449
449
450 :Examples:
450 :Examples:
451
451
452 In [16]: marquee('A test',40)
452 In [16]: marquee('A test',40)
453 Out[16]: '**************** A test ****************'
453 Out[16]: '**************** A test ****************'
454
454
455 In [17]: marquee('A test',40,'-')
455 In [17]: marquee('A test',40,'-')
456 Out[17]: '---------------- A test ----------------'
456 Out[17]: '---------------- A test ----------------'
457
457
458 In [18]: marquee('A test',40,' ')
458 In [18]: marquee('A test',40,' ')
459 Out[18]: ' A test '
459 Out[18]: ' A test '
460
460
461 """
461 """
462 if not txt:
462 if not txt:
463 return (mark*width)[:width]
463 return (mark*width)[:width]
464 nmark = (width-len(txt)-2)//len(mark)//2
464 nmark = (width-len(txt)-2)//len(mark)//2
465 if nmark < 0: nmark =0
465 if nmark < 0: nmark =0
466 marks = mark*nmark
466 marks = mark*nmark
467 return '%s %s %s' % (marks,txt,marks)
467 return '%s %s %s' % (marks,txt,marks)
468
468
469
469
470 ini_spaces_re = re.compile(r'^(\s+)')
470 ini_spaces_re = re.compile(r'^(\s+)')
471
471
472 def num_ini_spaces(strng):
472 def num_ini_spaces(strng):
473 """Return the number of initial spaces in a string"""
473 """Return the number of initial spaces in a string"""
474
474
475 ini_spaces = ini_spaces_re.match(strng)
475 ini_spaces = ini_spaces_re.match(strng)
476 if ini_spaces:
476 if ini_spaces:
477 return ini_spaces.end()
477 return ini_spaces.end()
478 else:
478 else:
479 return 0
479 return 0
480
480
481
481
482 def format_screen(strng):
482 def format_screen(strng):
483 """Format a string for screen printing.
483 """Format a string for screen printing.
484
484
485 This removes some latex-type format codes."""
485 This removes some latex-type format codes."""
486 # Paragraph continue
486 # Paragraph continue
487 par_re = re.compile(r'\\$',re.MULTILINE)
487 par_re = re.compile(r'\\$',re.MULTILINE)
488 strng = par_re.sub('',strng)
488 strng = par_re.sub('',strng)
489 return strng
489 return strng
490
490
491 def dedent(text):
491 def dedent(text):
492 """Equivalent of textwrap.dedent that ignores unindented first line.
492 """Equivalent of textwrap.dedent that ignores unindented first line.
493
493
494 This means it will still dedent strings like:
494 This means it will still dedent strings like:
495 '''foo
495 '''foo
496 is a bar
496 is a bar
497 '''
497 '''
498
498
499 For use in wrap_paragraphs.
499 For use in wrap_paragraphs.
500 """
500 """
501
501
502 if text.startswith('\n'):
502 if text.startswith('\n'):
503 # text starts with blank line, don't ignore the first line
503 # text starts with blank line, don't ignore the first line
504 return textwrap.dedent(text)
504 return textwrap.dedent(text)
505
505
506 # split first line
506 # split first line
507 splits = text.split('\n',1)
507 splits = text.split('\n',1)
508 if len(splits) == 1:
508 if len(splits) == 1:
509 # only one line
509 # only one line
510 return textwrap.dedent(text)
510 return textwrap.dedent(text)
511
511
512 first, rest = splits
512 first, rest = splits
513 # dedent everything but the first line
513 # dedent everything but the first line
514 rest = textwrap.dedent(rest)
514 rest = textwrap.dedent(rest)
515 return '\n'.join([first, rest])
515 return '\n'.join([first, rest])
516
516
517 def wrap_paragraphs(text, ncols=80):
517 def wrap_paragraphs(text, ncols=80):
518 """Wrap multiple paragraphs to fit a specified width.
518 """Wrap multiple paragraphs to fit a specified width.
519
519
520 This is equivalent to textwrap.wrap, but with support for multiple
520 This is equivalent to textwrap.wrap, but with support for multiple
521 paragraphs, as separated by empty lines.
521 paragraphs, as separated by empty lines.
522
522
523 Returns
523 Returns
524 -------
524 -------
525
525
526 list of complete paragraphs, wrapped to fill `ncols` columns.
526 list of complete paragraphs, wrapped to fill `ncols` columns.
527 """
527 """
528 paragraph_re = re.compile(r'\n(\s*\n)+', re.MULTILINE)
528 paragraph_re = re.compile(r'\n(\s*\n)+', re.MULTILINE)
529 text = dedent(text).strip()
529 text = dedent(text).strip()
530 paragraphs = paragraph_re.split(text)[::2] # every other entry is space
530 paragraphs = paragraph_re.split(text)[::2] # every other entry is space
531 out_ps = []
531 out_ps = []
532 indent_re = re.compile(r'\n\s+', re.MULTILINE)
532 indent_re = re.compile(r'\n\s+', re.MULTILINE)
533 for p in paragraphs:
533 for p in paragraphs:
534 # presume indentation that survives dedent is meaningful formatting,
534 # presume indentation that survives dedent is meaningful formatting,
535 # so don't fill unless text is flush.
535 # so don't fill unless text is flush.
536 if indent_re.search(p) is None:
536 if indent_re.search(p) is None:
537 # wrap paragraph
537 # wrap paragraph
538 p = textwrap.fill(p, ncols)
538 p = textwrap.fill(p, ncols)
539 out_ps.append(p)
539 out_ps.append(p)
540 return out_ps
540 return out_ps
541
541
542
542
543 class EvalFormatter(Formatter):
543 class EvalFormatter(Formatter):
544 """A String Formatter that allows evaluation of simple expressions.
544 """A String Formatter that allows evaluation of simple expressions.
545
545
546 Note that this version interprets a : as specifying a format string (as per
546 Note that this version interprets a : as specifying a format string (as per
547 standard string formatting), so if slicing is required, you must explicitly
547 standard string formatting), so if slicing is required, you must explicitly
548 create a slice.
548 create a slice.
549
549
550 This is to be used in templating cases, such as the parallel batch
550 This is to be used in templating cases, such as the parallel batch
551 script templates, where simple arithmetic on arguments is useful.
551 script templates, where simple arithmetic on arguments is useful.
552
552
553 Examples
553 Examples
554 --------
554 --------
555
555
556 In [1]: f = EvalFormatter()
556 In [1]: f = EvalFormatter()
557 In [2]: f.format('{n//4}', n=8)
557 In [2]: f.format('{n//4}', n=8)
558 Out [2]: '2'
558 Out [2]: '2'
559
559
560 In [3]: f.format("{greeting[slice(2,4)]}", greeting="Hello")
560 In [3]: f.format("{greeting[slice(2,4)]}", greeting="Hello")
561 Out [3]: 'll'
561 Out [3]: 'll'
562 """
562 """
563 def get_field(self, name, args, kwargs):
563 def get_field(self, name, args, kwargs):
564 v = eval(name, kwargs)
564 v = eval(name, kwargs)
565 return v, name
565 return v, name
566
566
567 @skip_doctest_py3
567 @skip_doctest_py3
568 class FullEvalFormatter(Formatter):
568 class FullEvalFormatter(Formatter):
569 """A String Formatter that allows evaluation of simple expressions.
569 """A String Formatter that allows evaluation of simple expressions.
570
570
571 Any time a format key is not found in the kwargs,
571 Any time a format key is not found in the kwargs,
572 it will be tried as an expression in the kwargs namespace.
572 it will be tried as an expression in the kwargs namespace.
573
573
574 Note that this version allows slicing using [1:2], so you cannot specify
574 Note that this version allows slicing using [1:2], so you cannot specify
575 a format string. Use :class:`EvalFormatter` to permit format strings.
575 a format string. Use :class:`EvalFormatter` to permit format strings.
576
576
577 Examples
577 Examples
578 --------
578 --------
579
579
580 In [1]: f = FullEvalFormatter()
580 In [1]: f = FullEvalFormatter()
581 In [2]: f.format('{n//4}', n=8)
581 In [2]: f.format('{n//4}', n=8)
582 Out[2]: u'2'
582 Out[2]: u'2'
583
583
584 In [3]: f.format('{list(range(5))[2:4]}')
584 In [3]: f.format('{list(range(5))[2:4]}')
585 Out[3]: u'[2, 3]'
585 Out[3]: u'[2, 3]'
586
586
587 In [4]: f.format('{3*2}')
587 In [4]: f.format('{3*2}')
588 Out[4]: u'6'
588 Out[4]: u'6'
589 """
589 """
590 # copied from Formatter._vformat with minor changes to allow eval
590 # copied from Formatter._vformat with minor changes to allow eval
591 # and replace the format_spec code with slicing
591 # and replace the format_spec code with slicing
592 def _vformat(self, format_string, args, kwargs, used_args, recursion_depth):
592 def _vformat(self, format_string, args, kwargs, used_args, recursion_depth):
593 if recursion_depth < 0:
593 if recursion_depth < 0:
594 raise ValueError('Max string recursion exceeded')
594 raise ValueError('Max string recursion exceeded')
595 result = []
595 result = []
596 for literal_text, field_name, format_spec, conversion in \
596 for literal_text, field_name, format_spec, conversion in \
597 self.parse(format_string):
597 self.parse(format_string):
598
598
599 # output the literal text
599 # output the literal text
600 if literal_text:
600 if literal_text:
601 result.append(literal_text)
601 result.append(literal_text)
602
602
603 # if there's a field, output it
603 # if there's a field, output it
604 if field_name is not None:
604 if field_name is not None:
605 # this is some markup, find the object and do
605 # this is some markup, find the object and do
606 # the formatting
606 # the formatting
607
607
608 if format_spec:
608 if format_spec:
609 # override format spec, to allow slicing:
609 # override format spec, to allow slicing:
610 field_name = ':'.join([field_name, format_spec])
610 field_name = ':'.join([field_name, format_spec])
611
611
612 # eval the contents of the field for the object
612 # eval the contents of the field for the object
613 # to be formatted
613 # to be formatted
614 obj = eval(field_name, kwargs)
614 obj = eval(field_name, kwargs)
615
615
616 # do any conversion on the resulting object
616 # do any conversion on the resulting object
617 obj = self.convert_field(obj, conversion)
617 obj = self.convert_field(obj, conversion)
618
618
619 # format the object and append to the result
619 # format the object and append to the result
620 result.append(self.format_field(obj, ''))
620 result.append(self.format_field(obj, ''))
621
621
622 return u''.join(py3compat.cast_unicode(s) for s in result)
622 return u''.join(py3compat.cast_unicode(s) for s in result)
623
623
624 @skip_doctest_py3
624 @skip_doctest_py3
625 class DollarFormatter(FullEvalFormatter):
625 class DollarFormatter(FullEvalFormatter):
626 """Formatter allowing Itpl style $foo replacement, for names and attribute
626 """Formatter allowing Itpl style $foo replacement, for names and attribute
627 access only. Standard {foo} replacement also works, and allows full
627 access only. Standard {foo} replacement also works, and allows full
628 evaluation of its arguments.
628 evaluation of its arguments.
629
629
630 Examples
630 Examples
631 --------
631 --------
632 In [1]: f = DollarFormatter()
632 In [1]: f = DollarFormatter()
633 In [2]: f.format('{n//4}', n=8)
633 In [2]: f.format('{n//4}', n=8)
634 Out[2]: u'2'
634 Out[2]: u'2'
635
635
636 In [3]: f.format('23 * 76 is $result', result=23*76)
636 In [3]: f.format('23 * 76 is $result', result=23*76)
637 Out[3]: u'23 * 76 is 1748'
637 Out[3]: u'23 * 76 is 1748'
638
638
639 In [4]: f.format('$a or {b}', a=1, b=2)
639 In [4]: f.format('$a or {b}', a=1, b=2)
640 Out[4]: u'1 or 2'
640 Out[4]: u'1 or 2'
641 """
641 """
642 _dollar_pattern = re.compile("(.*?)\$(\$?[\w\.]+)")
642 _dollar_pattern = re.compile("(.*?)\$(\$?[\w\.]+)")
643 def parse(self, fmt_string):
643 def parse(self, fmt_string):
644 for literal_txt, field_name, format_spec, conversion \
644 for literal_txt, field_name, format_spec, conversion \
645 in Formatter.parse(self, fmt_string):
645 in Formatter.parse(self, fmt_string):
646
646
647 # Find $foo patterns in the literal text.
647 # Find $foo patterns in the literal text.
648 continue_from = 0
648 continue_from = 0
649 txt = ""
649 txt = ""
650 for m in self._dollar_pattern.finditer(literal_txt):
650 for m in self._dollar_pattern.finditer(literal_txt):
651 new_txt, new_field = m.group(1,2)
651 new_txt, new_field = m.group(1,2)
652 # $$foo --> $foo
652 # $$foo --> $foo
653 if new_field.startswith("$"):
653 if new_field.startswith("$"):
654 txt += new_txt + new_field
654 txt += new_txt + new_field
655 else:
655 else:
656 yield (txt + new_txt, new_field, "", None)
656 yield (txt + new_txt, new_field, "", None)
657 txt = ""
657 txt = ""
658 continue_from = m.end()
658 continue_from = m.end()
659
659
660 # Re-yield the {foo} style pattern
660 # Re-yield the {foo} style pattern
661 yield (txt + literal_txt[continue_from:], field_name, format_spec, conversion)
661 yield (txt + literal_txt[continue_from:], field_name, format_spec, conversion)
662
662
663 #-----------------------------------------------------------------------------
664 # Utils to columnize a list of string
665 #-----------------------------------------------------------------------------
666 def _chunks(l, n):
667 """Yield successive n-sized chunks from l."""
668 for i in xrange(0, len(l), n):
669 yield l[i:i+n]
670
671 def _find_optimal(rlist , sepsize=2 , displaywidth=80):
672 """Calculate optimal info to columnize a list of string"""
673 for nrow in range(1, len(rlist)+1) :
674 chk = [max(l) for l in _chunks(rlist, nrow) ]
675 sumlength = sum(chk)
676 ncols = len(chk)
677 if sumlength+sepsize*(ncols-1) <= displaywidth :
678 break;
679 return {'columns_numbers' : ncols,
680 'optimal_separator_width':(displaywidth - sumlength)/(ncols-1) if (ncols -1) else 0,
681 'rows_numbers' : nrow,
682 'columns_width' : chk
683 }
684
685 def _get_or_default(mylist, i, default=None):
686 """return list item number, or default if don't exist"""
687 if i >= len(mylist):
688 return default
689 else :
690 return mylist[i]
691
692 def compute_item_matrix(items, *args, **kwargs) :
693 """ Transform a list of strings into a nested list to columnize
694
695 Returns a tuple of (strings_matrix, dict_info)
696
697 innermost lists are rows, see columnize for options info
698 """
699 info = _find_optimal(map(len, items), *args, **kwargs)
700 nrow, ncol = info['rows_numbers'], info['columns_numbers']
701 return ([[ _get_or_default(items, c*nrow+i) for c in range(ncol) ] for i in range(nrow) ], info)
663
702
664 def columnize(items, separator=' ', displaywidth=80):
703 def columnize(items, separator=' ', displaywidth=80):
665 """ Transform a list of strings into a single string with columns.
704 """ Transform a list of strings into a single string with columns.
666
705
667 Parameters
706 Parameters
668 ----------
707 ----------
669 items : sequence of strings
708 items : sequence of strings
670 The strings to process.
709 The strings to process.
671
710
672 separator : str, optional [default is two spaces]
711 separator : str, optional [default is two spaces]
673 The string that separates columns.
712 The string that separates columns.
674
713
675 displaywidth : int, optional [default is 80]
714 displaywidth : int, optional [default is 80]
676 Width of the display in number of characters.
715 Width of the display in number of characters.
677
716
678 Returns
717 Returns
679 -------
718 -------
680 The formatted string.
719 The formatted string.
681 """
720 """
682 # Note: this code is adapted from columnize 0.3.2.
721 if not items :
683 # See http://code.google.com/p/pycolumnize/
684
685 # Some degenerate cases.
686 size = len(items)
687 if size == 0:
688 return '\n'
722 return '\n'
689 elif size == 1:
723 matrix, info = compute_item_matrix(items, sepsize=len(separator), displaywidth=displaywidth)
690 return '%s\n' % items[0]
724 #sep = ' '*min(info['optimal_separator_width'], 9)
691
725 fmatrix = matrix
692 # Special case: if any item is longer than the maximum width, there's no
726 fmatrix = [filter(None, x) for x in matrix]
693 # point in triggering the logic below...
727 sjoin = lambda x : separator.join([ y.ljust(w, ' ') for y, w in zip(x, info['columns_width'])])
694 item_len = map(len, items) # save these, we can reuse them below
728 return '\n'.join(map(sjoin, fmatrix))+'\n'
695 longest = max(item_len)
696 if longest >= displaywidth:
697 return '\n'.join(items+[''])
698
699 # Try every row count from 1 upwards
700 array_index = lambda nrows, row, col: nrows*col + row
701 for nrows in range(1, size):
702 ncols = (size + nrows - 1) // nrows
703 colwidths = []
704 totwidth = -len(separator)
705 for col in range(ncols):
706 # Get max column width for this column
707 colwidth = 0
708 for row in range(nrows):
709 i = array_index(nrows, row, col)
710 if i >= size: break
711 x, len_x = items[i], item_len[i]
712 colwidth = max(colwidth, len_x)
713 colwidths.append(colwidth)
714 totwidth += colwidth + len(separator)
715 if totwidth > displaywidth:
716 break
717 if totwidth <= displaywidth:
718 break
719
720 # The smallest number of rows computed and the max widths for each
721 # column has been obtained. Now we just have to format each of the rows.
722 string = ''
723 for row in range(nrows):
724 texts = []
725 for col in range(ncols):
726 i = row + nrows*col
727 if i >= size:
728 texts.append('')
729 else:
730 texts.append(items[i])
731 while texts and not texts[-1]:
732 del texts[-1]
733 for col in range(len(texts)):
734 texts[col] = texts[col].ljust(colwidths[col])
735 string += '%s\n' % separator.join(texts)
736 return string
General Comments 0
You need to be logged in to leave comments. Login now