def vformat(self, format_string, args, kwargs):
matcher = re.compile(self._expr, re.VERBOSE)
# special case of returning the object if the entire string
# matches a single parameter
try:
result = re.match('^%s$' % self._expr, format_string, re.VERBOSE)
except TypeError:
return format_string.format(**kwargs)
if result is not None:
try:
return kwargs[result.group("key")]
except KeyError:
pass
# handle multiple fields within string via a callback to re.sub()
def re_replace(match):
key = match.group("key")
default = match.group("default")
if default is not None:
if key not in kwargs:
return default
else:
return "{%s}" % key
return match.group(0)
format_string = matcher.sub(re_replace, format_string)
return Formatter.vformat(self, format_string, args, kwargs)
def vformat(self, format_string, args, kwargs):
self.unused_args = {}
ret = Formatter.vformat(self, format_string, args, kwargs)
if not self.unused_args:
return ret
extra_data = ', '.join('{0}={1}'.format(*kv) for kv in self.unused_args.items())
return '{0} ({1})'.format(ret, extra_data)
def pformat(temp, **fmt):
"""Format a template string partially.
Examples
--------
>>> pformat("{a}_{b}", a='x')
'x_{b}'
"""
formatter = Formatter()
mapping = _FormatDict(fmt)
return formatter.vformat(temp, (), mapping)
def make_tag():
today = datetime.datetime.today()
date = today.strftime(date_format)
print(date)
seq=1
"git tag --list=release/%s/*" % date
values={
"date": date,
"sequence": seq
}
formatter = Formatter()
tag = formatter.vformat(tag_format, [], values)
print(tag)
def _write_to_file(table_a_dest,
genome_ids_a,
genome_ids_b,
common_prefix_a,
common_prefix_b,
calculations):
'''
:param table_a_dest:
:type table_a_dest: filename
:param genome_ids_a:
:type genome_ids_a: list or genome ids
:param common_prefix_a:
:type common_prefix_a: string
:param common_prefix_b:
:type common_prefix_b: string
:param calculations:
:type calculations: list of clade_calcs instances
'''
with open(table_a_dest, 'a') as write_handle:
# Print introduction about the strain comparison
write_handle.write('#{} {} strains compared with {} {} strains\n'.format(len(genome_ids_a),
common_prefix_a,
len(genome_ids_b),
common_prefix_b))
# Print the genome IDs involved in each of the strains
write_handle.write('#IDs {}: {}\n'.format(common_prefix_a,
', '.join(genome_ids_a)))
write_handle.write('#IDs {}: {}\n'.format(common_prefix_b,
', '.join(genome_ids_b)))
# Print column headers for the data to come
max_nton = len(genome_ids_a) // 2
headers = _get_column_headers(max_nton)
write_handle.write('#' + '\t'.join(headers))
write_handle.write('\n')
# Print data rows
format_str = '\t'.join('{{{}}}'.format(key) for key in headers)
from string import Formatter
formatter = Formatter()
for clade_calcs in calculations:
write_handle.write(formatter.vformat(format_str, None, clade_calcs.values))
write_handle.write('\n')
def resolve_conf(unresolved):
"""take a config with values using string formatting; apply string formatting until they all don't;
returns (dict of things that could be resolved, dict of things that couldn't be resolved)"""
f = Formatter()
resolved = {}
while unresolved:
changed_something, missing_defs = False, []
for k, v in unresolved.items():
if isinstance(v, basestring) and v and tuple(f.parse(v))[0][1] is not None:
try:
unresolved[k] = f.vformat(v, [], resolved)
changed_something = True
except KeyError, e: # missing a definition; but could in the next pass if we changed something
missing_defs.append(e.args[0])
else:
# non strings are, by definition, resolved; no recursion into complex data structures here
# items without format specifiers are also resolved
del unresolved[k]
resolved[k] = v
changed_something = True
if not changed_something:
break
def on_query_completions(self, view, prefix, locations):
# Only trigger within LaTeX
if not view.match_selector(locations[0],
"text.tex.latex"):
return []
point = locations[0]
try:
completions, prefix, post_brace, new_point_a, new_point_b = get_cite_completions(view, point, autocompleting=True)
except UnrecognizedCiteFormatError:
return []
except NoBibFilesError:
sublime.status_message("No bib files found!")
return []
except BibParsingError as e:
sublime.status_message("Bibliography " + e.filename + " is broken!")
return []
# filter against keyword or title
if prefix:
completions = [comp for comp in completions if prefix.lower() in "%s %s" %
(
comp['keyword'].lower(),
comp['title'].lower())]
prefix += " "
# get preferences for formating of autocomplete entries
cite_autocomplete_format = get_setting('cite_autocomplete_format',
"{keyword}: {title}")
formatter = Formatter()
r = [(prefix + formatter.vformat(cite_autocomplete_format, (), completion),
completion['keyword'] + post_brace) for completion in completions]
# print "%d bib entries matching %s" % (len(r), prefix)
return r
def f(string, *args, **kwargs):
"""
String safe substitute format method.
If you pass extra keys they will be ignored.
If you pass incomplete substitute map, missing keys will be left unchanged.
:param string:
:param kwargs:
:return:
>>> f('{foo} {bar}', foo="FOO")
'FOO {bar}'
>>> f('{} {bar}', 1)
'1 {bar}'
>>> f('{foo} {}', 1)
'{foo} 1'
>>> f('{foo} {} {bar} {}', '|', bar='BAR')
'{foo} | BAR {}'
>>> f('{foo} {bar}', foo="FOO", bro="BRO")
'FOO {bar}'
"""
formatter = Formatter()
args_mapping = FormatTuple(args)
mapping = FormatDict(kwargs)
return formatter.vformat(string, args_mapping, mapping)
def run(self, edit):
# get view and location of first selection, which we expect to be just the cursor position
view = self.view
point = view.sel()[0].b
print (point)
# Only trigger within LaTeX
# Note using score_selector rather than match_selector
if not view.score_selector(point,
"text.tex.latex"):
return
try:
completions, prefix, post_brace, new_point_a, new_point_b = get_cite_completions(view, point)
except UnrecognizedCiteFormatError:
sublime.error_message("Not a recognized format for citation completion")
return
except NoBibFilesError:
sublime.error_message("No bib files found!")
return
except BibParsingError as e:
sublime.error_message("Bibliography " + e.filename + " is broken!")
return
except BibParsingError as e:
sublime.error_message(e.message)
return
# filter against keyword, title, or author
if prefix:
completions = [comp for comp in completions if prefix.lower() in "%s %s %s" %
(
comp['keyword'].lower(),
comp['title'].lower(),
comp['author'].lower())]
# Note we now generate citation on the fly. Less copying of vectors! Win!
def on_done(i):
print ("latex_cite_completion called with index %d" % (i,) )
# Allow user to cancel
if i < 0:
return
keyword = completions[i]['keyword']
# notify any plugins
notification_thread = threading.Thread(
target=run_plugin_command,
args=(
'on_insert_citation',
keyword
),
kwargs={
'stop_on_first': False,
'expect_result': False
}
)
notification_thread.daemon = True
notification_thread.start()
cite = completions[i]['keyword'] + post_brace
#print("DEBUG: types of new_point_a and new_point_b are " + repr(type(new_point_a)) + " and " + repr(type(new_point_b)))
# print "selected %s:%s by %s" % completions[i][0:3]
# Replace cite expression with citation
# the "latex_tools_replace" command is defined in latex_ref_cite_completions.py
view.run_command("latex_tools_replace", {"a": new_point_a, "b": new_point_b, "replacement": cite})
# Unselect the replaced region and leave the caret at the end
caret = view.sel()[0].b
view.sel().subtract(view.sel()[0])
view.sel().add(sublime.Region(caret, caret))
# get preferences for formating of quick panel
cite_panel_format = get_setting('cite_panel_format',
["{title} ({keyword})", "{author}"])
completions_length = len(completions)
if completions_length == 0:
return
elif completions_length == 1:
# only one entry, so insert entry
view.run_command("latex_tools_replace",
{
"a": new_point_a,
"b": new_point_b,
"replacement": completions[0]['keyword'] + post_brace
}
)
# Unselect the replaced region and leave the caret at the end
caret = view.sel()[0].b
view.sel().subtract(view.sel()[0])
view.sel().add(sublime.Region(caret, caret))
else:
# show quick
formatter = Formatter()
view.window().show_quick_panel([[formatter.vformat(s, (), completion) for s in cite_panel_format] \
for completion in completions], on_done)
def run(self, edit):
# get view and location of first selection, which we expect to be just the cursor position
view = self.view
point = view.sel()[0].b
print (point)
# Only trigger within LaTeX
# Note using score_selector rather than match_selector
if not view.score_selector(point,
"text.tex.latex"):
return
try:
completions, prefix, post_brace, new_point_a, new_point_b = get_cite_completions(view, point)
except UnrecognizedCiteFormatError:
sublime.error_message("Not a recognized format for citation completion")
return
except NoBibFilesError:
sublime.error_message("No bib files found!")
return
except BibParsingError as e:
sublime.error_message("Bibliography " + e.filename + " is broken!")
return
except BibParsingError as e:
sublime.error_message(e.message)
return
# filter against keyword, title, or author
if prefix:
completions = [comp for comp in completions if prefix.lower() in "%s %s %s" %
(
comp['keyword'].lower(),
comp['title'].lower(),
comp['author'].lower())]
# Note we now generate citation on the fly. Less copying of vectors! Win!
def on_done(i):
print ("latex_cite_completion called with index %d" % (i,) )
# Allow user to cancel
if i < 0:
return
keyword = completions[i]['keyword']
# notify any plugins
notification_thread = threading.Thread(
target=run_plugin_command,
args=(
'on_insert_citation',
keyword
),
kwargs={
'stop_on_first': False,
'expect_result': False
}
)
notification_thread.daemon = True
notification_thread.start()
cite = completions[i]['keyword'] + post_brace
#print("DEBUG: types of new_point_a and new_point_b are " + repr(type(new_point_a)) + " and " + repr(type(new_point_b)))
# print "selected %s:%s by %s" % completions[i][0:3]
# Replace cite expression with citation
# the "latex_tools_replace" command is defined in latex_ref_cite_completions.py
view.run_command("latex_tools_replace", {"a": new_point_a, "b": new_point_b, "replacement": cite})
# Unselect the replaced region and leave the caret at the end
caret = view.sel()[0].b
view.sel().subtract(view.sel()[0])
view.sel().add(sublime.Region(caret, caret))
# get preferences for formating of quick panel
cite_panel_format = get_setting('cite_panel_format',
["{title} ({keyword})", "{author}"])
completions_length = len(completions)
if completions_length == 0:
return
elif completions_length == 1:
# only one entry, so insert entry
view.run_command("latex_tools_replace",
{
"a": new_point_a,
"b": new_point_b,
"replacement": completions[0]['keyword'] + post_brace
}
)
# Unselect the replaced region and leave the caret at the end
caret = view.sel()[0].b
view.sel().subtract(view.sel()[0])
view.sel().add(sublime.Region(caret, caret))
else:
# show quick
formatter = Formatter()
view.window().show_quick_panel([[formatter.vformat(s, (), completion) for s in cite_panel_format] \
for completion in completions], on_done)
def dictformat(string, dictionary):
formatter = Formatter()
return formatter.vformat(string, (), dictionary)
class Env(object):
"""
Stores config settings for fusionbox fabric helper routines. Dynamically
builds the value of certain properties unless their value was manually set.
NOTE:
Be careful not to define properties that reference each other...will cause
a stack overflow.
"""
DEFAULTS = {
# Global defaults
"transport_method": "git",
"tld": ".com",
"web_home": "/var/www",
"workon_home": "/var/python-environments",
"backups_dir": "backups",
"media_dir": "media",
"virtualenv": "{project_name}",
"vassal": "{project_name}",
# Dev defaults
"dev_project_name": "{project_name}",
"dev_tld": "{tld}",
"dev_web_home": "{web_home}",
"dev_virtualenv": "{virtualenv}",
"dev_vassal": "{vassal}",
"dev_workon_home": "{workon_home}",
"dev_project_dir": "{dev_project_name}{dev_tld}",
"dev_project_path": "{dev_web_home}/{dev_project_dir}",
"dev_virtualenv_path": "{dev_workon_home}/{dev_virtualenv}",
"dev_restart_cmd": "sudo touch /etc/vassals/{dev_vassal}.ini",
"dev_backups_dir": "{backups_dir}",
"dev_media_dir": "{media_dir}",
"dev_media_path": "{dev_project_path}/{dev_media_dir}",
# Live defaults
"live_project_name": "{project_name}",
"live_tld": "{tld}",
"live_web_home": "{web_home}",
"live_virtualenv": "{virtualenv}",
"live_vassal": "{vassal}",
"live_workon_home": "{workon_home}",
"live_project_dir": "{live_project_name}{live_tld}",
"live_project_path": "{live_web_home}/{live_project_dir}",
"live_virtualenv_path": "{live_workon_home}/{live_virtualenv}",
"live_restart_cmd": "sudo touch /etc/vassals/{live_vassal}.ini",
"live_backups_dir": "{backups_dir}",
"live_media_dir": "{media_dir}",
"live_media_path": "{live_project_path}/{live_media_dir}",
# Local defaults
"local_backups_dir": "{backups_dir}",
"local_media_dir": "{media_dir}",
}
def __init__(self):
self._formatter = Formatter()
def __getattr__(self, name):
if name in self.DEFAULTS:
# If there is a default value format, build the default value
return self._format(self.DEFAULTS[name])
else:
raise AttributeError("'{0}' object has no attribute '{1}'".format(type(self).__name__, name))
def __getitem__(self, key):
return getattr(self, key)
def _format(self, f):
# Use a string formatter instance so we can use any object that defines
# __getitem__
return self._formatter.vformat(f, None, self)
def role(self, role, name):
return getattr(self, role + "_" + name)
class CpuUsage(IntervalModule):
"""
Shows CPU usage.
The first output will be inacurate.
Linux only
.. rubric:: Available formatters
* `{usage}` — usage average of all cores
* `{usage_cpu*}` — usage of one specific core. replace "*" by core number starting at 0
* `{usage_all}` — usage of all cores separate. usess natsort when available(relevant for more than 10 cores)
"""
format = "{usage:02}%"
format_all = "{core}:{usage:02}%"
exclude_average = False
interval = 1
color = None
settings = (
("format", "format string."),
("format_all", ("format string used for {usage_all} per core. "
"Available formaters are {core} and {usage}. ")),
("exclude_average", ("If True usage average of all cores will "
"not be in format_all.")),
("color", "HTML color code #RRGGBB")
)
def init(self):
self.prev_total = defaultdict(int)
self.prev_busy = defaultdict(int)
self.formatter = Formatter()
def get_cpu_timings(self):
"""
reads and parses /proc/stat
returns dictionary with all available cores including global average
"""
timings = {}
with open('/proc/stat', 'r') as file_obj:
for line in file_obj:
if 'cpu' in line:
line = line.strip().split()
timings[line[0]] = [int(x) for x in line[1:]]
return timings
def calculate_usage(self, cpu, total, busy):
"""
calculates usage
"""
diff_total = total - self.prev_total[cpu]
diff_busy = busy - self.prev_busy[cpu]
self.prev_total[cpu] = total
self.prev_busy[cpu] = busy
if diff_total == 0:
return 0
else:
return int(diff_busy / diff_total * 100)
def gen_format_all(self, usage):
"""
generates string for format all
"""
format_string = " "
core_strings = []
for core, usage in usage.items():
if core == 'usage_cpu' and self.exclude_average:
continue
elif core == 'usage':
continue
core = core.replace('usage_', '')
string = self.formatter.vformat(self.format_all, (),
{'core': core, 'usage': usage})
core_strings.append(string)
core_strings = sorted(core_strings)
return format_string.join(core_strings)
def get_usage(self):
"""
parses /proc/stat and calcualtes total and busy time
(more specific USER_HZ see man 5 proc for further informations )
"""
usage = {}
for cpu, timings in self.get_cpu_timings().items():
cpu_total = sum(timings)
del timings[3:5]
cpu_busy = sum(timings)
cpu_usage = self.calculate_usage(cpu, cpu_total, cpu_busy)
usage['usage_' + cpu] = cpu_usage
# for backward compatibility
usage['usage'] = usage['usage_cpu']
return usage
def run(self):
usage = self.get_usage()
usage['usage_all'] = self.gen_format_all(usage)
self.data = usage
self.output = {
"full_text": self.format.format_map(usage),
"color": self.color
}
def dictformat(string, dictionary):
formatter = Formatter()
return formatter.vformat(string, (), dictionary)
def test_dot(self):
f=Formatter()
x=Str('bla')
x.x='foo'
self.assertEqual(f.vformat('{x}{x.x}',[], {'x':x}), 'blafoo')
def test_dot(self):
f = Formatter()
x = Str('bla')
x.x = 'foo'
self.assertEqual(f.vformat('{x}{x.x}', [], {'x': x}), 'blafoo')
