forked from imp/nfstest
-
Notifications
You must be signed in to change notification settings - Fork 0
/
formatstr.py
212 lines (189 loc) · 8.99 KB
/
formatstr.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
#===============================================================================
# Copyright 2014 NetApp, Inc. All Rights Reserved,
# contribution by Jorge Mora <mora@netapp.com>
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation; either version 2 of the License, or (at your option) any later
# version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#===============================================================================
"""
String Formatter object
Object used to format base objects into strings. It extends the functionality
of the string Formatter object to include new modifiers for different objects.
Some of these new modifiers include conversion of strings into a sequence
of hex characters, conversion of strings to their corresponding CRC32 or
CRC16 representation.
"""
import re
import time
import nfstest_config as c
from string import Formatter
from binascii import crc32,crc_hqx
# Module constants
__author__ = 'Jorge Mora (%s)' % c.NFSTEST_AUTHOR_EMAIL
__version__ = '1.0.1'
__copyright__ = "Copyright (C) 2014 NetApp, Inc."
__license__ = "GPL v2"
# Maximum integer map
_max_map = {
"max32":{
0x7fffffff: "max32",
-0x80000000: "-max32",
},
"umax32":{
0xffffffff: "umax32",
},
"max64":{
0x7fffffffffffffff: "max64",
-0x8000000000000000: "-max64",
},
"umax64":{
0xffffffffffffffff: "umax64",
},
}
class FormatStr(Formatter):
"""String Formatter object
FormatStr() -> New string formatter object
Usage:
from formatstr import FormatStr
x = FormatStr()
out = x.format(fmt_spec, *args, **kwargs)
out = x.vformat(fmt_spec, args, kwargs)
Arguments should be surrounded by curly braces {}, anything that is
not contained in curly braces is considered literal text which is
copied unchanged to the output.
Positional arguments to be used in the format spec are specified
by their index: {0}, {1}, etc.
Named arguments to be used in the format spec are specified by
their name: {name1}, {name2}, etc.
Modifiers are specified after the positional index or name preceded
by a ":", "{0:#x}" -- display first positional argument in hex
Examples:
# Format string using positional arguments
out = x.format("{0} -> {1}", a, b)
# Format string using named arguments
out = x.format("{key}: {value}", key="id", value=32)
# Format string using both positional and named arguments
out = x.format("{key}: {value}, {0}, {1}", a, b, key="id", value=32)
# Use vformat() method instead when positional arguments are given
# as a list and named arguments are given as a dictionary
# The following examples show the same as above
pos_args = [a, b]
named_args = {"key":"id", "value":32}
out = x.vformat("{0} -> {1}", pos_args)
out = x.vformat("{key}: {value}", named_args)
out = x.vformat("{key}: {value}, {0}, {1}", pos_args, named_args)
# Convert string into hex
out = x.format("{0:x}", "hello") # out = "68656c6c6f"
# Convert string into hex with leading 0x
out = x.format("{0:#x}", "hello") # out = "0x68656c6c6f"
# Convert string into crc32
out = x.format("{0:crc32}", "hello") # out = "0x3610a686"
# Convert string into crc16
out = x.format("{0:crc16}", "hello") # out = "0x9c62"
# Substring using "@" format modifier
# Format {0:@sindex[,eindex]} is like value[sindex:eindex]
# {0:@3} is like value[3:]
# {0:@3,5} is like value[3:5]
# {0:.5} is like value[:5]
out = x.format("{0:@3}", "hello") # out = "lo"
out = x.format("{0:.2}", "hello") # out = "he"
# Integer extension to display umax name instead of the value
# Format: {0:max32|umax32|max64|umax64}
# Output: if value matches the largest number in format given,
# the max name is displayed, else the value is displayed
out = x.format("{0:max32}", 0x7fffffff) # out = "max32"
out = x.format("{0:max32}", 35) # out = "35"
# Date extension for int, long or float
# Format: {0:date[:datefmt]}
# The spec given by datefmt is converted using strftime()
# The conversion spec "%q" is used to display microseconds
# Output: display value as a date
stime = 1416846041.521868
out = x.format("{0:date}", stime) # out = "Mon Nov 24 09:20:41 2014"
out = x.format("{0:date:%Y-%m-%d}", stime) # out = "2014-11-24"
# List format specification
# Format: {0[[:listfmt]:itemfmt]}
# If one format spec, it is applied to each item in the list
# If two format specs, the first is the item separator and
# the second is the spec applied to each item in the list
alist = [1, 2, 3, 0xffffffff]
out = x.format("{0:umax32}", alist) # out = "[1, 2, 3, umax32]"
out = x.format("{0:--:umax32}", alist) # out = "1--2--3--umax32"
"""
def format_field(self, value, format_spec):
"""Override original method to include modifier extensions"""
if value is None:
# No value is given
return ""
# Process format spec
match = re.search(r"([#@]?)(\d*)(.*)", format_spec)
xmod, num, fmt = match.groups()
if isinstance(value, int) and type(value) != int:
# This is an object derived from int, convert it to string
value = str(value)
if isinstance(value, str):
if fmt == "x":
# Display string in hex
xprefix = ""
if xmod == "#":
xprefix = "0x"
return xprefix + value.encode("hex")
elif fmt == "crc32":
# CRC32 format
return "{0:#010x}".format(crc32(value) & 0xffffffff)
elif fmt == "crc16":
# CRC16 format
return "{0:#06x}".format(crc_hqx(value, 0xa5a5) & 0xffff)
elif xmod == "@":
# Format {0:@starindex[,endindex]} is like value[starindex:endindex]
# {0:@3} is like value[3:]
# {0:@3,5} is like value[3:5]
# {0:.5} is like value[:5]
end = 0
if len(fmt) > 2 and fmt[0] == ",":
end = int(fmt[1:])
return value[int(num):end]
else:
return value[int(num):]
elif isinstance(value, list):
# Format: {0[[:listfmt]:itemfmt]}
if len(format_spec):
fmts = format_spec.split(":", 1)
ifmt = "{0:" + fmts[-1] + "}"
vlist = [self.format(ifmt, x) for x in value]
if len(fmts) == 2:
# Two format specs, use the first one for the list itself
# and the second spec is for each item in the list
return fmts[0].join(vlist)
# Only one format spec is given, display list with format spec
# applied to each item in the list
return "[" + ", ".join(vlist) + "]"
elif isinstance(value, int) or isinstance(value, long) or isinstance(value, float):
if _max_map.get(fmt):
# Format: {0:max32|umax32|max64|umax64}
# Output: if value matches the largest number in format given,
# the max name is displayed, else the value is displayed
# {0:max32}: value:0x7fffffff then "max32" is displayed
# {0:max32}: value:35 then 35 is displayed
return _max_map[fmt].get(value, str(value))
elif fmt[:4] == "date":
# Format: {0:date[:datefmt]}
# Output: display value as a date
# value: 1416846041.521868
# display: 'Mon Nov 24 09:20:41 2014'
dfmt = "%c" # Default date spec when datefmt is not given
fmts = fmt.split(":", 1)
if len(fmts) == 2:
dfmt = fmts[1]
if dfmt.find("%q"):
# Replace all instances of %q with the microseconds
usec = "%06d" % (1000000 * (value - int(value)))
dfmt = dfmt.replace("%q", usec)
return time.strftime(dfmt, time.localtime(value))
return format(value, format_spec)