def configure_locale():
logger.debug("Before %s", locale.nl_langinfo(locale.CODESET))
current_locale = locale.getlocale()
if current_locale[1] is None:
logger.debug("No locale currently set. Attempting to get default locale.")
default_locale = locale.getdefaultlocale()
if default_locale[1] is None:
logger.debug("No default locale exists. Let's try loading from /etc/default/locale")
if os.path.exists("/etc/default/locale"):
config = ConfigObj('/etc/default/locale')
lang = config.get('LANG')
new_locale = lang
else:
logger.error("/etc/default/locale could not be found! Please run 'sudo update-locale' from command-line.")
sys.exit(1)
else:
new_locale = default_locale
logger.info("New locale set to: %s", locale.setlocale(locale.LC_ALL, new_locale))
reload(sys)
sys.setdefaultencoding("UTF-8")
current_locale_encoding = locale.getlocale()[1].lower()
logger.debug("sys default encoding %s", sys.getdefaultencoding())
logger.debug("After %s", locale.nl_langinfo(locale.CODESET))
if current_locale_encoding not in ['utf-8', 'utf8']:
logger.error("Need a UTF-8 locale. Currently '%s'. Exiting..." % current_locale_encoding)
sys.exit(1)
def __init__(self):
# load the locale's month names and abbreviations
self.months = {}
for i in range(1, 13):
for basename in ['MON_{}', 'ABMON_{}']:
index = locale.__dict__[basename.format(i)]
name = locale.nl_langinfo(index).lower()
self.months[name] = i
# load the locale's weekday names and abbreviations
self.weekdays = {}
for i in range(1, 8):
for basename in ['DAY_{}', 'ABDAY_{}']:
index = locale.__dict__[basename.format(i)]
name = locale.nl_langinfo(index).lower()
self.weekdays[name] = i
# compile the cron entry pattern
self.cron_pattern = re.compile(r'''
(?: (?P<all> \*)
(?: \s* / \s* (?P<allincr> \d+ ) )? [, \t]* ) |
(?: (?P<start> \w+)
(?: \s* - \s*
(?P<end> \w+ )
(?: \s* / \s* (?P<incr> \d+ ) )? )? [, \t]* ) |
(?P<comma>,)|
(?P<cruft>\S+?)
''',
re.VERBOSE)
def from_data(self, uid, fields, rows, model):
pageSize=[210.0,297.0]
new_doc = etree.Element("report")
config = etree.SubElement(new_doc, 'config')
def _append_node(name, text):
n = etree.SubElement(config, name)
n.text = text
_append_node('date', time.strftime(str(locale.nl_langinfo(locale.D_FMT).replace('%y', '%Y'))))
_append_node('PageSize', '%.2fmm,%.2fmm' % tuple(pageSize))
_append_node('PageWidth', '%.2f' % (pageSize[0] * 2.8346,))
_append_node('PageHeight', '%.2f' %(pageSize[1] * 2.8346,))
_append_node('PageFormat', 'a4')
_append_node('header-date', time.strftime(str(locale.nl_langinfo(locale.D_FMT).replace('%y', '%Y'))))
l = []
t = 0
temp = []
tsum = []
header = etree.SubElement(new_doc, 'header')
for f in fields:
field = etree.SubElement(header, 'field')
field.text = tools.ustr(f)
lines = etree.SubElement(new_doc, 'lines')
for row_lines in rows:
node_line = etree.SubElement(lines, 'row')
for row in row_lines:
col = etree.SubElement(node_line, 'col', para='yes', tree='no')
col.text = tools.ustr(row)
transform = etree.XSLT(
etree.parse(os.path.join(tools.config['root_path'],
'addons/base/report/custom_new.xsl')))
rml = etree.tostring(transform(new_doc))
self.obj = trml2pdf.parseNode(rml, title='Printscreen')
return self.obj
def load_lang(self, cr, uid, lang, lang_name=None):
# create the language with locale information
fail = True
iso_lang = tools.get_iso_codes(lang)
for ln in tools.get_locales(lang):
try:
locale.setlocale(locale.LC_ALL, str(ln))
fail = False
break
except locale.Error:
continue
if fail:
lc = locale.getdefaultlocale()[0]
msg = 'Unable to get information for locale %s. Information from the default locale (%s) have been used.'
_logger.warning(msg, lang, lc)
if not lang_name:
lang_name = tools.ALL_LANGUAGES.get(lang, lang)
def fix_xa0(s):
"""Fix badly-encoded non-breaking space Unicode character from locale.localeconv(),
coercing to utf-8, as some platform seem to output localeconv() in their system
encoding, e.g. Windows-1252"""
if s == '\xa0':
return '\xc2\xa0'
return s
def fix_datetime_format(format):
"""Python's strftime supports only the format directives
that are available on the platform's libc, so in order to
be 100% cross-platform we map to the directives required by
the C standard (1989 version), always available on platforms
with a C standard implementation."""
# For some locales, nl_langinfo returns a D_FMT/T_FMT that contains
# unsupported '%-' patterns, e.g. for cs_CZ
format = format.replace('%-', '%')
for pattern, replacement in tools.DATETIME_FORMATS_MAP.iteritems():
format = format.replace(pattern, replacement)
return str(format)
conv = locale.localeconv()
lang_info = {
'code': lang,
'iso_code': iso_lang,
'name': lang_name,
'translatable': 1,
'date_format' : fix_datetime_format(locale.nl_langinfo(locale.D_FMT)),
'time_format' : fix_datetime_format(locale.nl_langinfo(locale.T_FMT)),
'decimal_point' : fix_xa0(str(conv['decimal_point'])),
'thousands_sep' : fix_xa0(str(conv['thousands_sep'])),
'grouping' : str(conv.get('grouping', [])),
}
lang_id = False
try:
lang_id = self.create(cr, uid, lang_info)
finally:
tools.resetlocale()
return lang_id
def confirm(self, msg):
msg = unicode(msg)
if ctx.config.options and ctx.config.options.yes_all:
return True
import re, tty
try:
locale.setlocale(locale.LC_ALL, "")
except:
# Ignore "unsupported locale setting" errors
pass
yes_expr = re.compile(locale.nl_langinfo(locale.YESEXPR))
no_expr = re.compile(locale.nl_langinfo(locale.NOEXPR))
locale.setlocale(locale.LC_ALL, "C")
while True:
tty.tcflush(sys.stdin.fileno(), 0)
prompt = msg + pisi.util.colorize(_(' (yes/no)'), 'red')
s = raw_input(prompt.encode('utf-8'))
if yes_expr.search(s):
return True
if no_expr.search(s):
return False
def displayAttributeValue(self, value):
'''
Convert QGIS attribute data into readable values
'''
# QGIS version
isQgis2 = self.QgisVersion > 10900
# Get locale date representation
locale.setlocale(locale.LC_TIME,'')
if hasattr(locale, 'nl_langinfo'):
date_format = locale.nl_langinfo(locale.D_FMT)
datetime_format = locale.nl_langinfo(locale.D_T_FMT)
else:
date_format = "%x"
datetime_format = "%x %X"
# Convert value depending of type
if hasattr(value, 'toPyDate'):
output = value.toPyDate().strftime(date_format)
elif hasattr(value, 'toPyDateTime'):
output = value.toPyDateTime().strftime(datetime_format)
else:
output = u"%s" % value if isQgis2 else u"%s" % value.toString()
return output
def _fallback(self, loc):
# Fallback to system locale
l10n = {}
# TIME
old = locale.setlocale(locale.LC_TIME)
l10n['LC_TIME'] = {}
try:
locale.setlocale(locale.LC_TIME, _normalize(loc))
except locale.Error:
return
#
try:
for what in (
locale.D_T_FMT, locale.D_FMT, locale.T_FMT, locale.T_FMT_AMPM,
locale.DAY_1, locale.DAY_2, locale.DAY_3, locale.DAY_4,
locale.DAY_5, locale.DAY_6, locale.DAY_7,
locale.ABDAY_1, locale.ABDAY_2, locale.ABDAY_3, locale.ABDAY_4,
locale.ABDAY_5, locale.ABDAY_6, locale.ABDAY_7,
locale.MON_1, locale.MON_2, locale.MON_3, locale.MON_4,
locale.MON_5, locale.MON_6, locale.MON_7, locale.MON_8,
locale.MON_9, locale.MON_10, locale.MON_11, locale.MON_12,
locale.ABMON_1, locale.ABMON_2, locale.ABMON_3, locale.ABMON_4,
locale.ABMON_5, locale.ABMON_6, locale.ABMON_7, locale.ABMON_8,
locale.ABMON_9, locale.ABMON_10, locale.ABMON_11, locale.ABMON_12,
locale.ERA, locale.ERA_D_T_FMT, locale.ERA_D_FMT,
):
l10n['LC_TIME'][what] = l10n[what] = locale.nl_langinfo(what)
#
finally:
locale.setlocale(locale.LC_TIME, old)
#
# numbers
# TIME
old = locale.setlocale(locale.LC_NUMERIC)
l10n['LC_NUMERIC'] = {}
l10n['LC_MONETARY'] = {}
try:
locale.setlocale(locale.LC_NUMERIC, _normalize(loc))
except locale.Error:
return
#
try:
l10n['LC_MONETARY'] = locale.localeconv()
for what in (locale.ALT_DIGITS, locale.RADIXCHAR, locale.THOUSEP):
l10n['LC_MONETARY'][what] = l10n[what] = locale.nl_langinfo(what)
finally:
locale.setlocale(locale.LC_NUMERIC, old)
#
l10n['LC_NUMERIC']['decimal_point'] = l10n['LC_MONETARY']['decimal_point']
l10n['LC_NUMERIC']['thousands_sep'] = l10n['LC_MONETARY']['thousands_sep']
l10n['LC_NUMERIC']['grouping'] = l10n['LC_MONETARY']['grouping']
#
self._loc_info = copy.deepcopy(l10n) # XXX Is this is really needed?
def _get_date_text(self):
if self.display_year:
return datetime.datetime.now().strftime(locale.nl_langinfo(locale.D_FMT))
else:
dformat = locale.nl_langinfo(locale.D_FMT)
for s in [ "/%y", "/%Y", ".%y", ".%Y", ".%y", ".%Y" ]:
dformat = dformat.replace(s, "")
return datetime.datetime.now().strftime(dformat)
def getpreferredencoding(do_setlocale=True):
if do_setlocale:
oldloc = locale.setlocale(locale.LC_CTYPE)
locale.setlocale(locale.LC_CTYPE, "")
result = locale.nl_langinfo(locale.CODESET)
locale.setlocale(locale.LC_CTYPE, oldloc)
return result
else:
return locale.nl_langinfo(locale.CODESET)
def testTrueDiv(self):
x = SizeStruct.new_from_str("1024 B")
y = SizeStruct.new_from_str("-102.4 B") # rounds to whole bytes
divResult = float(x.true_div(y)[:15].replace(locale.nl_langinfo(locale.RADIXCHAR), ".")) # just some number to cover accurancy and not cross max float range
self.assertAlmostEqual(divResult, 1024.0/-102.0)
x = SizeStruct.new_from_str("1 MiB")
y = SizeStruct.new_from_str("1 KiB")
divResult = float(x.true_div(y)[:15].replace(locale.nl_langinfo(locale.RADIXCHAR), ".")) # just some number to cover accurancy and not cross max float range
self.assertAlmostEqual(divResult, 1024.0)
def compile_filters(filter_list):
"""Compile a list of comma-separated-values into a single flat list"""
result = []
for filter_str in filter_list:
items = csv.reader(StringIO(filter_str.encode(locale.nl_langinfo(locale.CODESET))),
quotechar='`',
skipinitialspace=True).next()
for item in items:
result.append(unicode(item, locale.nl_langinfo(locale.CODESET)))
return result
def from_data(self, uid, fields, rows, company_name):
pageSize=[210.0,297.0]
new_doc = etree.Element("report")
config = etree.SubElement(new_doc, 'config')
def _append_node(name, text):
n = etree.SubElement(config, name)
n.text = text
_append_node('date', time.strftime(str(locale.nl_langinfo(locale.D_FMT).replace('%y', '%Y'))))
_append_node('PageSize', '%.2fmm,%.2fmm' % tuple(pageSize))
_append_node('PageWidth', '%.2f' % (pageSize[0] * 2.8346,))
_append_node('PageHeight', '%.2f' %(pageSize[1] * 2.8346,))
_append_node('PageFormat', 'a4')
_append_node('header-date', time.strftime(str(locale.nl_langinfo(locale.D_FMT).replace('%y', '%Y'))))
_append_node('company', company_name)
l = []
t = 0
temp = []
tsum = []
skip_index = []
header = etree.SubElement(new_doc, 'header')
i = 0
for f in fields:
if f.get('header_data_id', False):
value = f.get('header_name', "")
field = etree.SubElement(header, 'field')
field.text = tools.ustr(value)
else:
skip_index.append(i)
i += 1
lines = etree.SubElement(new_doc, 'lines')
for row_lines in rows:
node_line = etree.SubElement(lines, 'row')
j = 0
for row in row_lines:
if not j in skip_index:
para = "yes"
tree = "no"
value = row.get('data', '')
if row.get('bold', False):
para = "group"
if row.get('number', False):
tree = "float"
col = etree.SubElement(node_line, 'col', para=para, tree=tree)
col.text = tools.ustr(value)
j += 1
transform = etree.XSLT(
etree.parse(os.path.join(tools.config['root_path'],
'addons/base/report/custom_new.xsl')))
rml = etree.tostring(transform(new_doc))
# Update system font database if it hasn't been called yet, so that system fonts are used by reportlab with better glyph coverage
registry = openerp.registry(request.cr.dbname)
registry['res.font'].font_scan(request.cr, SUPERUSER_ID, lazy=True, context=request.context)
self.obj = trml2pdf.parseNode(rml, title='Printscreen')
return self.obj
def getpreferredencoding(do_setlocale = True):
"""Return the charset that the user is likely using,
according to the system configuration."""
if do_setlocale:
oldloc = locale.setlocale(locale.LC_CTYPE)
locale.setlocale(locale.LC_CTYPE, "")
result = locale.nl_langinfo(locale.CODESET)
locale.setlocale(locale.LC_CTYPE, oldloc)
return result
else:
return locale.nl_langinfo(locale.CODESET)
def get_date(schedule=False, rule=None, last_date=None, tz=None, iso8601=False):
"""Returns a date stamp, given a recurrence rule.
schedule - bool:
whether to use the recurrence rule or not
rule - str:
an iCal RRULE string that specifies the rule for scheduling posts
last_date - datetime:
timestamp of the last post
tz - tzinfo:
the timezone used for getting the current time.
iso8601 - bool:
whether to force ISO 8601 dates (instead of locale-specific ones)
"""
if tz is None:
tz = dateutil.tz.tzlocal()
date = now = datetime.datetime.now(tz)
if schedule:
try:
from dateutil import rrule
except ImportError:
LOGGER.error('To use the --schedule switch of new_post, '
'you have to install the "dateutil" package.')
rrule = None # NOQA
if schedule and rrule and rule:
try:
rule_ = rrule.rrulestr(rule, dtstart=last_date)
except Exception:
LOGGER.error('Unable to parse rule string, using current time.')
else:
date = rule_.after(max(now, last_date or now), last_date is None)
offset = tz.utcoffset(now)
offset_sec = (offset.days * 24 * 3600 + offset.seconds)
offset_hrs = offset_sec // 3600
offset_min = offset_sec % 3600
if iso8601:
tz_str = '{0:+03d}:{1:02d}'.format(offset_hrs, offset_min // 60)
return date.strftime('%Y-%m-%dT%T') + tz_str
else:
if offset:
tz_str = ' UTC{0:+03d}:{1:02d}'.format(offset_hrs, offset_min // 60)
else:
tz_str = ' UTC'
return date.strftime('{0} {1}'.format(
locale.nl_langinfo(locale.D_FMT),
locale.nl_langinfo(locale.T_FMT),
)) + tz_str
def from_data(self, uid, fields, rows, company_name):
pageSize = [210.0, 297.0]
new_doc = etree.Element("report")
config = etree.SubElement(new_doc, "config")
def _append_node(name, text):
n = etree.SubElement(config, name)
n.text = text
_append_node("date", time.strftime(str(locale.nl_langinfo(locale.D_FMT).replace("%y", "%Y"))))
_append_node("PageSize", "%.2fmm,%.2fmm" % tuple(pageSize))
_append_node("PageWidth", "%.2f" % (pageSize[0] * 2.8346,))
_append_node("PageHeight", "%.2f" % (pageSize[1] * 2.8346,))
_append_node("PageFormat", "a4")
_append_node("header-date", time.strftime(str(locale.nl_langinfo(locale.D_FMT).replace("%y", "%Y"))))
_append_node("company", company_name)
l = []
t = 0
temp = []
tsum = []
skip_index = []
header = etree.SubElement(new_doc, "header")
i = 0
for f in fields:
if f.get("header_data_id", False):
value = f.get("header_name", "")
field = etree.SubElement(header, "field")
field.text = tools.ustr(value)
else:
skip_index.append(i)
i += 1
lines = etree.SubElement(new_doc, "lines")
for row_lines in rows:
node_line = etree.SubElement(lines, "row")
j = 0
for row in row_lines:
if not j in skip_index:
para = "yes"
tree = "no"
value = row.get("data", "")
if row.get("bold", False):
para = "group"
if row.get("number", False):
tree = "float"
col = etree.SubElement(node_line, "col", para=para, tree=tree)
col.text = tools.ustr(value)
j += 1
transform = etree.XSLT(
etree.parse(os.path.join(tools.config["root_path"], "addons/base/report/custom_new.xsl"))
)
rml = etree.tostring(transform(new_doc))
self.obj = trml2pdf.parseNode(rml, title="Printscreen")
return self.obj
def load_lang(self, cr, uid, lang, lang_name=None):
# create the language with locale information
fail = True
iso_lang = tools.get_iso_codes(lang)
for ln in tools.get_locales(lang):
try:
locale.setlocale(locale.LC_ALL, str(ln))
fail = False
break
except locale.Error:
continue
if fail:
lc = locale.getdefaultlocale()[0]
msg = "Unable to get information for locale %s. Information from the default locale (%s) have been used."
_logger.warning(msg, lang, lc)
if not lang_name:
lang_name = tools.ALL_LANGUAGES.get(lang, lang)
def fix_xa0(s):
"""Fix badly-encoded non-breaking space Unicode character from locale.localeconv(),
coercing to utf-8, as some platform seem to output localeconv() in their system
encoding, e.g. Windows-1252"""
if s == "\xa0":
return "\xc2\xa0"
return s
def fix_datetime_format(format):
"""Python's strftime supports only the format directives
that are available on the platform's libc, so in order to
be 100% cross-platform we map to the directives required by
the C standard (1989 version), always available on platforms
with a C standard implementation."""
for pattern, replacement in tools.DATETIME_FORMATS_MAP.iteritems():
format = format.replace(pattern, replacement)
return str(format)
lang_info = {
"code": lang,
"iso_code": iso_lang,
"name": lang_name,
"translatable": 1,
"date_format": fix_datetime_format(locale.nl_langinfo(locale.D_FMT)),
"time_format": fix_datetime_format(locale.nl_langinfo(locale.T_FMT)),
"decimal_point": fix_xa0(str(locale.localeconv()["decimal_point"])),
"thousands_sep": fix_xa0(str(locale.localeconv()["thousands_sep"])),
}
lang_id = False
try:
lang_id = self.create(cr, uid, lang_info)
finally:
tools.resetlocale()
return lang_id
def _dt_format(self, cfg=None):
"""
Not sure how reliable this method of formatting the dt string is.
Different locales may impact formatting items. Need unit-tests heh
"""
if cfg is None:
cfg = self.config
dt_format = ""
if cfg.show_time:
if cfg.show_dt:
dt_format = locale.nl_langinfo(locale.D_T_FMT)
else: # NOT show_dt
dt_format = locale.nl_langinfo(locale.T_FMT)
debug_log("dt_format:in1: '" + dt_format + "'")
if "%r" in dt_format:
if cfg.show_sec:
if cfg.show_12hr:
dt_format = re.sub("%r", "%I:%M:%S %p", dt_format)
else:
dt_format = re.sub("%r", "%H:%M:%S", dt_format)
else:
if cfg.show_12hr:
dt_format = re.sub("%r", "%I:%M %p", dt_format)
else:
dt_format = re.sub("%r", "%H:%M", dt_format)
if cfg.show_tz:
if "%Z" not in dt_format:
dt_format = dt_format + " %Z"
else:
if "%Z" in dt_format:
dt_format = re.sub("\s*%Z", "", dt_format)
else: # NOT show_time
dt_format = locale.nl_langinfo(locale.D_T_FMT)
debug_log("dt_format:in2: '" + dt_format + "'")
if "%r" in dt_format:
dt_format = re.sub("\s??%r", "", dt_format)
if "%Z" in dt_format:
dt_format = re.sub("\s??%Z", "", dt_format)
if " %Y" in dt_format:
if cfg.show_yr and not self.config.show_dt:
dt_format = "%Y, " + dt_format
elif cfg.show_yr:
if cfg.show_time:
dt_format = re.sub(" %Y ", ", %Y, ", dt_format)
else:
dt_format = re.sub(" %Y", ", %Y", dt_format)
else:
dt_format = re.sub(" %Y", "", dt_format)
if cfg.show_time and cfg.show_dt and not cfg.show_yr:
dt_format = re.sub("%b %", "%b, %", dt_format)
debug_log("dt_format:out: '" + dt_format + "'")
return dt_format
def datestampConvert(datestamp):
try:
dtFormat = "%Y%m%d%H%M%S"
dtString = str(datestamp)
dtConverted = datetime.datetime.strptime(dtString, dtFormat)
# Localise date and time
dtLocaleDate = locale.nl_langinfo(locale.D_FMT)
dtLocaleTime = locale.nl_langinfo(locale.T_FMT)
dtShow = dtConverted.strftime(dtLocaleDate)
except:
# Could not get datestamp from file
dtShow='-'
return dtShow
def __init__(self, code='fr', conv=None):
self.tz = pytz.timezone(pytz.country_timezones[code][0])
days_sym = [locale.DAY_1, locale.DAY_2, locale.DAY_3, locale.DAY_4,
locale.DAY_5, locale.DAY_6, locale.DAY_7]
months_sym = [locale.DAY_1, locale.DAY_2, locale.DAY_3, locale.DAY_4,
locale.DAY_5, locale.DAY_6, locale.DAY_7, locale.MON_8,
locale.MON_9, locale.MON_10, locale.MON_11, locale.MON_12]
self.days = [locale.nl_langinfo(d) for d in days_sym]
self.months = [locale.nl_langinfo(d) for d in months_sym]
if conv is None:
locale.setlocale(locale.LC_ALL, '')
self.date_fmt = locale.nl_langinfo(locale.D_FMT) + ' %Z%z'
self.hour_fmt = locale.nl_langinfo(locale.T_FMT) + ' %Z%z'
def test_get_set_from_str(self):
datetime_obj = datetime(1977, 12, 31, 12, 34, 56)
datetime_fmt = "%s %s" %(locale.nl_langinfo(locale.D_FMT),
locale.nl_langinfo(locale.T_FMT))
datetime_str = datetime.strftime(datetime_obj, datetime_fmt)
datetime_uni = unicode(datetime_str)
variable = DateTimeVariable()
variable.set(datetime_str, from_db=False)
self.assertEquals(variable.get(), datetime_obj)
variable.set(datetime_uni, from_db=False)
self.assertEquals(variable.get(), datetime_obj)
variable.set(datetime_obj, from_db=False)
self.assertEquals(variable.get(), datetime_obj)
def process_dates(self, date_from, date_to):
"""Wrap the process_dates method in log_time to log total execution time"""
log_time(
target=super().process_dates,
target_args=[
date_from,
date_to
],
message='{prefix} {date_from} to {date_to}'.format(
prefix=self.message_prefix,
date_from=date_from.strftime(locale.nl_langinfo(locale.D_FMT)),
date_to=date_to.strftime(locale.nl_langinfo(locale.D_FMT))
)
)
def size_from_input(input_str, units=None):
""" Get a Size object from an input string.
:param str input_str: a string forming some representation of a size
:param units: use these units if none specified in input_str
:type units: str or NoneType
:returns: a Size object corresponding to input_str
:rtype: :class:`blivet.size.Size` or NoneType
Units default to bytes if no units in input_str or units.
"""
if not input_str:
# Nothing to parse
return None
# A string ending with a digit contains no units information.
if re.search(r'[\d.%s]$' % locale.nl_langinfo(locale.RADIXCHAR), input_str):
input_str += units or ""
try:
size = Size(input_str)
except ValueError:
return None
return size
def testTranslated(self):
s = Size("56.19 MiB")
for lang in self.TEST_LANGS:
os.environ['LANG'] = lang
locale.setlocale(locale.LC_ALL, '')
# Check English parsing
self.assertEqual(s, Size("56.19 MiB"))
# Check native parsing
self.assertEqual(s, Size("56.19 %s%s" % (_("Mi"), _("B"))))
# Check native parsing, all lowercase
self.assertEqual(s, Size(("56.19 %s%s" % (_("Mi"), _("B"))).lower()))
# Check native parsing, all uppercase
self.assertEqual(s, Size(("56.19 %s%s" % (_("Mi"), _("B"))).upper()))
# If the radix separator is not a period, repeat the tests with the
# native separator
radix = locale.nl_langinfo(locale.RADIXCHAR)
if radix != '.':
self.assertEqual(s, Size("56%s19 MiB" % radix))
self.assertEqual(s, Size("56%s19 %s%s" % (radix, _("Mi"), _("B"))))
self.assertEqual(s, Size(("56%s19 %s%s" % (radix, _("Mi"), _("B"))).lower()))
self.assertEqual(s, Size(("56%s19 %s%s" % (radix, _("Mi"), _("B"))).upper()))
def stats(self):
"""Prints a nicely formatted list of statistics about the package"""
self.downloads # explicitly call, so we have first/last upload data
fmt = locale.nl_langinfo(locale.D_T_FMT)
sep = lambda s: locale.format('%d', s, 3)
val = lambda dt: dt and dt.strftime(fmt) or '--'
params = (
self.package_name,
val(self.first_upload),
self.first_upload_rel,
val(self.last_upload),
self.last_upload_rel,
sep(len(self.releases)),
sep(self.max()),
sep(self.min()),
sep(self.average()),
sep(self.total()),
)
print """PyPI Package statistics for: %s
First Upload: %40s (%s)
Last Upload: %40s (%s)
Number of releases: %34s
Most downloads: %35s
Fewest downloads: %35s
Average downloads: %35s
Total downloads: %35s
""" % params
def _date_localed_sequence():
s = locale.nl_langinfo(locale.D_FMT).lower()
s2 = [ c for c in s if c in ("y", "m", "d") ]
if len(s2) < 3:
# Eeek!
return ['y', 'm', 'd']
return s2
def udecode(data, encoding='ascii'):
if (encoding and encoding.lower() == 'unicode'
or isinstance(data, UnicodeType)):
return unicode(data)
encodings = [encoding, 'utf-8']
try:
encodings.append(locale.nl_langinfo(locale.CODESET))
except:
pass
try:
encodings.append(locale.getlocale()[1])
except:
pass
try:
encodings.append(locale.getdefaultlocale()[1])
except:
pass
encodings.append('latin-1')
for enc in encodings:
if not enc:
continue
try:
return unicode(data, enc)
except (UnicodeError, LookupError):
pass
raise UnicodeError(
'Unable to decode input data. Tried the following encodings: %s.'
% ', '.join([repr(enc) for enc in encodings if enc]))
def time_format(self, abbreviated=False):
""" The format string for a time value.
Parameters
----------
abbreviated : bool, optional
If True, return the abbreviate version of the time format.
The defaults is False.
Returns
-------
result : string
The time format string.
"""
if sys.platform == 'win32':
if abbreviated:
key = 'ab_time'
else:
key = 'time'
r = _win_defaults[key]
else:
flag = locale.T_FMT if abbreviated else locale.T_FMT_AMPM
r = locale.nl_langinfo(flag)
return unicode(r)
def datetime_format(self, abbreviated=False):
""" The format string for a datetime value.
Parameters
----------
abbreviated : bool, optional
If True, return the abbreviated version of the datetime
format. The defaults is False.
Returns
-------
result : string
The datetime format string.
Notes
-----
Python's builtin locale (based on langinfo) does not distinguish
abbreviated and non-abbreviated datetime formats. So the keyword
argument is ignored in this implementation.
"""
if sys.platform == 'win32':
r = _win_defaults['datetime']
else:
# Python doesn't support %e in strptime, but %d is equivalent
r = locale.nl_langinfo(locale.D_T_FMT).replace('%e', '%d')
return unicode(r)
def currency(value, request=None, grouping=True):
"""
e.g.
import locale
locale.setlocale(locale.LC_ALL, 'de_CH.UTF-8')
currency(123456.789) # Fr. 123'456.79
currency(-123456.789) # <span class="negative">Fr. -123'456.79</span>
"""
if not value:
value = 0.0
shop = lfs.core.utils.get_default_shop(request)
try:
result = locale.currency(value, grouping=grouping, international=shop.use_international_currency_code)
except ValueError:
result = value
# add css class if value is negative
if value < 0:
# replace the minus symbol if needed
if result[-1] == '-':
length = len(locale.nl_langinfo(locale.CRNCYSTR))
result = '%s-%s' % (result[0:length], result[length:-1])
return mark_safe('<span class="negative">%s</span>' % result)
return result
def day_name(self, day_int, abbreviated=False):
""" The day name for the given day integer.
Parameters
----------
day_int : int
An integer in the range 1 to 7 inclusive.
abbreviated : bool, optional
If True, return the abbreviate version of the day name.
The default is False.
Returns
-------
result : string
The day name or an empty string in the day int is out
of range.
"""
if day_int < 1 or day_int > 7:
return ''
if sys.platform == 'win32':
if abbreviated:
key = 'ab_days'
else:
key = 'days'
r = _win_defaults[key][day_int]
else:
prefix = 'AB' if abbreviated else ''
attr = prefix + ('DAY_%i' % day_int)
flag = getattr(locale, attr)
r = locale.nl_langinfo(flag)
return unicode(r)
def writeScript(self, expPath=None, target="PsychoPy", modular=True):
"""Write a PsychoPy script for the experiment
"""
self.integrityCheck()
self.psychopyVersion = psychopy.__version__ # make sure is current
# set this so that params write for approp target
utils.scriptTarget = target
self.expPath = expPath
script = IndentingBuffer(u'') # a string buffer object
# get date info, in format preferred by current locale as set by app:
if hasattr(locale, 'nl_langinfo'):
fmt = locale.nl_langinfo(locale.D_T_FMT)
localDateTime = data.getDateStr(format=fmt)
else:
localDateTime = data.getDateStr(format="%B %d, %Y, at %H:%M")
# Remove disabled components, but leave original experiment unchanged.
self_copy = deepcopy(self)
for _, routine in list(self_copy.routines.items()): # PY2/3 compat
for component in routine:
try:
if component.params['disabled'].val:
routine.removeComponent(component)
except KeyError:
pass
if target == "PsychoPy":
self_copy.settings.writeInitCode(script, self_copy.psychopyVersion,
localDateTime)
# Write "run once" code sections
for entry in self_copy.flow:
# NB each entry is a routine or LoopInitiator/Terminator
self_copy._currentRoutine = entry
if hasattr(entry, 'writeRunOnceInitCode'):
entry.writeRunOnceInitCode(script)
script.write("\n\n")
# present info, make logfile
self_copy.settings.writeStartCode(script,
self_copy.psychopyVersion)
# writes any components with a writeStartCode()
self_copy.flow.writeStartCode(script)
self_copy.settings.writeWindowCode(
script) # create our visual.Window()
# for JS the routine begin/frame/end code are funcs so write here
# write the rest of the code for the components
self_copy.flow.writeBody(script)
self_copy.settings.writeEndCode(script) # close log file
script = script.getvalue()
elif target == "PsychoJS":
script.oneIndent = " " # use 2 spaces rather than python 4
self_copy.settings.writeInitCodeJS(script,
self_copy.psychopyVersion,
localDateTime, modular)
self_copy.flow.writeFlowSchedulerJS(script)
self_copy.settings.writeExpSetupCodeJS(script,
self_copy.psychopyVersion)
# initialise the components for all Routines in a single function
script.writeIndentedLines("\nfunction experimentInit() {")
script.setIndentLevel(1, relative=True)
# routine init sections
for entry in self_copy.flow:
# NB each entry is a routine or LoopInitiator/Terminator
self_copy._currentRoutine = entry
if hasattr(entry, 'writeInitCodeJS'):
entry.writeInitCodeJS(script)
# create globalClock etc
code = ("// Create some handy timers\n"
"globalClock = new util.Clock();"
" // to track the time since experiment started\n"
"routineTimer = new util.CountdownTimer();"
" // to track time remaining of each (non-slip) routine\n"
"\nreturn Scheduler.Event.NEXT;")
script.writeIndentedLines(code)
script.setIndentLevel(-1, relative=True)
script.writeIndentedLines("}\n")
# This differs to the Python script. We can loop through all
# Routines once (whether or not they get used) because we're using
# functions that may or may not get called later.
# Do the Routines of the experiment first
routinesToWrite = list(self_copy.routines)
for thisItem in self_copy.flow:
if thisItem.getType() in ['LoopInitiator', 'LoopTerminator']:
self_copy.flow.writeLoopHandlerJS(script, modular)
elif thisItem.name in routinesToWrite:
self_copy._currentRoutine = self_copy.routines[
thisItem.name]
self_copy._currentRoutine.writeRoutineBeginCodeJS(
script, modular)
self_copy._currentRoutine.writeEachFrameCodeJS(
script, modular)
self_copy._currentRoutine.writeRoutineEndCodeJS(
script, modular)
routinesToWrite.remove(thisItem.name)
self_copy.settings.writeEndCodeJS(script)
# Add JS variable declarations e.g., var msg;
script = py2js.addVariableDeclarations(script.getvalue(),
fileName=self.expPath)
# Reset loop controller ready for next call to writeScript
self_copy.flow._resetLoopController()
return script
lfs.core.views.one_time_setup()
if not value:
value = 0.0
shop = lfs.core.utils.get_default_shop(request)
try:
result = locale.currency(value, grouping=grouping, international=shop.use_international_currency_code)
except ValueError, e:
result = value
logger.error("currency filter: %s" % e)
if value < 0:
# replace the minus symbol if needed
if result[-1] == '-':
length = len(locale.nl_langinfo(locale.CRNCYSTR))
result = '%s-%s' % (result[0:length], result[length:-1])
return result
@register.filter
def currency(value, request=None, grouping=True):
"""
Returns the currency based on the given locale within settings.LFS_LOCALE
e.g.
import locale
locale.setlocale(locale.LC_ALL, 'de_CH.UTF-8')
currency(123456.789) # <span class="money">Fr. 123'456.79</span>
currency(-123456.789) # <span class="money negative">Fr. -123'456.79</span>
def _create_table(self,
uid,
ids,
fields,
fields_order,
results,
context,
title=''):
pageSize = [297.0, 210.0]
new_doc = etree.Element("report")
config = etree.SubElement(new_doc, 'config')
def _append_node(name, text):
n = etree.SubElement(config, name)
n.text = text
#_append_node('date', time.strftime('%d/%m/%Y'))
_append_node(
'date',
time.strftime(
str(locale.nl_langinfo(locale.D_FMT).replace('%y', '%Y'))))
_append_node('PageSize', '%.2fmm,%.2fmm' % tuple(pageSize))
_append_node('PageWidth', '%.2f' % (pageSize[0] * 2.8346, ))
_append_node('PageHeight', '%.2f' % (pageSize[1] * 2.8346, ))
_append_node('report-header', title)
_append_node(
'company',
pooler.get_pool(self.cr.dbname).get('res.users').browse(
self.cr, uid, uid).company_id.name)
rpt_obj = pooler.get_pool(self.cr.dbname).get('res.users')
rml_obj = report_sxw.rml_parse(self.cr, uid, rpt_obj._name, context)
_append_node(
'header-date',
str(rml_obj.formatLang(time.strftime("%Y-%m-%d"), date=True)) +
' ' + str(time.strftime("%H:%M")))
l = []
t = 0
strmax = (pageSize[0] - 40) * 2.8346
temp = []
tsum = []
for i in range(0, len(fields_order)):
temp.append(0)
tsum.append(0)
ince = -1
for f in fields_order:
s = 0
ince += 1
if fields[f]['type'] in ('date', 'time', 'datetime', 'float',
'integer'):
s = 60
strmax -= s
if fields[f]['type'] in ('float', 'integer'):
temp[ince] = 1
else:
t += fields[f].get('size', 80) / 28 + 1
l.append(s)
for pos in range(len(l)):
if not l[pos]:
s = fields[fields_order[pos]].get('size', 80) / 28 + 1
l[pos] = strmax * s / t
_append_node('tableSize', ','.join(map(str, l)))
header = etree.SubElement(new_doc, 'header')
for f in fields_order:
field = etree.SubElement(header, 'field')
field.text = tools.ustr(fields[f]['string'] or '')
lines = etree.SubElement(new_doc, 'lines')
for line in results:
node_line = etree.SubElement(lines, 'row')
count = -1
for f in fields_order:
float_flag = 0
count += 1
if fields[f]['type'] == 'many2one' and line[f]:
if not line.get('__group'):
line[f] = line[f][1]
if fields[f]['type'] == 'selection' and line[f]:
for key, value in fields[f]['selection']:
if key == line[f]:
line[f] = value
break
if fields[f]['type'] in ('one2many', 'many2many') and line[f]:
line[f] = '( ' + tools.ustr(len(line[f])) + ' )'
if fields[f]['type'] == 'float' and line[f]:
precision = (('digits' in fields[f])
and fields[f]['digits'][1]) or 2
prec = '%.' + str(precision) + 'f'
line[f] = prec % (line[f])
float_flag = 1
if fields[f]['type'] == 'date' and line[f]:
new_d1 = line[f]
if not line.get('__group'):
format = str(
locale.nl_langinfo(locale.D_FMT).replace(
'%y', '%Y'))
d1 = datetime.strptime(line[f], '%Y-%m-%d')
new_d1 = d1.strftime(format)
line[f] = new_d1
if fields[f]['type'] == 'time' and line[f]:
new_d1 = line[f]
if not line.get('__group'):
format = str(locale.nl_langinfo(locale.T_FMT))
d1 = datetime.strptime(line[f], '%H:%M:%S')
new_d1 = d1.strftime(format)
line[f] = new_d1
if fields[f]['type'] == 'datetime' and line[f]:
new_d1 = line[f]
if not line.get('__group'):
format = str(
locale.nl_langinfo(locale.D_FMT).replace(
'%y', '%Y')) + ' ' + str(
locale.nl_langinfo(locale.T_FMT))
d1 = datetime.strptime(line[f], '%Y-%m-%d %H:%M:%S')
new_d1 = d1.strftime(format)
line[f] = new_d1
if line.get('__group'):
col = etree.SubElement(node_line,
'col',
para='group',
tree='no')
else:
col = etree.SubElement(node_line,
'col',
para='yes',
tree='no')
# Prevent empty labels in groups
if f == line.get('__grouped_by') and line.get(
'__group'
) and not line[f] and not float_flag and not temp[count]:
col.text = line[f] = 'Undefined'
col.set('tree', 'undefined')
if line[f] != None:
col.text = tools.ustr(line[f] or '')
if float_flag:
col.set('tree', 'float')
if line.get('__no_leaf') and temp[
count] == 1 and f != 'id' and not line[
'__context']['group_by']:
tsum[count] = float(tsum[count]) + float(line[f])
if not line.get(
'__group') and f != 'id' and temp[count] == 1:
tsum[count] = float(tsum[count]) + float(line[f])
else:
col.text = '/'
node_line = etree.SubElement(lines, 'row')
for f in range(0, len(fields_order)):
col = etree.SubElement(node_line, 'col', para='group', tree='no')
col.set('tree', 'float')
if tsum[f] != None:
if tsum[f] != 0.0:
digits = fields[fields_order[f]].get('digits', (16, 2))
prec = '%%.%sf' % (digits[1], )
total = prec % (tsum[f], )
txt = str(total or '')
else:
txt = str(tsum[f] or '')
else:
txt = '/'
if f == 0:
txt = 'Total'
col.set('tree', 'no')
col.text = tools.ustr(txt or '')
transform = etree.XSLT(
etree.parse(
os.path.join(tools.config['root_path'],
'addons/base/report/custom_new.xsl')))
rml = etree.tostring(transform(new_doc))
self.obj = render.rml(rml, title=self.title)
self.obj.render()
return True
#!/usr/bin/env python3
#
# Copyright 2007 Doug Hellmann.
#
"""Print dates in locale-specfic format.
"""
#end_pymotw_header
import locale
import time
sample_locales = [
('USA', 'en_US'),
('France', 'fr_FR'),
('Spain', 'es_ES'),
('Portugal', 'pt_PT'),
('Poland', 'pl_PL'),
]
for name, loc in sample_locales:
locale.setlocale(locale.LC_ALL, loc)
format = locale.nl_langinfo(locale.D_T_FMT)
print('{:>10}: {}'.format(name, time.strftime(format)))
def main(argv):
locale.setlocale(locale.LC_ALL, '')
deflang = locale.getlocale(locale.LC_COLLATE)[0] or 'en_GB'
defenc = locale.nl_langinfo(locale.CODESET) or 'utf-8'
argparser = argparse.ArgumentParser()
argparser.add_argument(
'-e',
'--encoding',
action='store',
dest='encoding',
help='Character encoding to use for I/O (locale default: %s)' % defenc)
argparser.add_argument(
'-l',
'--language',
action='store',
dest='language',
help='The language to lookup the hyphenation rules for '
'(locale default: %s)' % deflang)
typearg = argparser.add_mutually_exclusive_group()
typearg.add_argument('-t',
'--text',
action='store_const',
dest='processor',
const=hyph_text,
help='Process files as plain text files (default)')
typearg.add_argument('-x',
'--xhtml',
action='store_const',
dest='processor',
const=hyph_xhtml,
help='Process files as XHTML')
argparser.add_argument('file', nargs='+')
argparser.set_defaults(encoding=defenc,
language=deflang,
processor=hyph_text)
opts = argparser.parse_args()
try:
h = pyphen.Pyphen(lang=opts.language)
except IOError as e:
argparser.error('unknown language: %s (%s)' % (opts.language, str(e)))
for path in opts.file:
try:
with codecs.open(path, 'r', opts.encoding) as f:
try:
with tempfile.NamedTemporaryFile(
delete=False, mode='w',
encoding=opts.encoding) as outf:
opts.processor(f, outf, h)
shutil.move(outf.name, path)
except Exception as e:
try:
os.unlink(outf.name)
except:
pass
raise e
except IOError as e:
sys.stderr.write('open() failed: %s\n' % str(e))
except LookupError as e:
argparser.error(str(e))
return 0
sys.path.append(NETCONFDIR)
# Workaround for buggy gtk/gnome commandline parsing python bindings.
cmdline = sys.argv[1:]
sys.argv = sys.argv[:1]
import locale
try:
locale.setlocale(locale.LC_ALL, "")
except locale.Error, e:
import os
os.environ['LC_ALL'] = 'C'
locale.setlocale(locale.LC_ALL, "")
import gettext
gettext.bind_textdomain_codeset(PROGNAME, locale.nl_langinfo(locale.CODESET))
gettext.bindtextdomain(PROGNAME, '/usr/share/locale')
gettext.textdomain(PROGNAME)
_ = lambda x: gettext.lgettext(x)
import __builtin__
__builtin__.__dict__['_'] = _
import signal
import os
import os.path
try:
import gtk
except RuntimeError:
sys.stderr.write(
def date_to_str(date, fmt=locale.nl_langinfo(locale.D_FMT)):
return date.strftime(fmt)
def confirm(self):
response = self.ttyask('apt-listchanges: ' +
_('Do you want to continue? [Y/n] '))
return response == '' or re.search(locale.nl_langinfo(locale.YESEXPR),
response)
def display(self, models):
self._models = models
if not self.chart:
if self._type == 'pie':
self.chart = GraphicsPieChartItem()
else:
self.chart = GraphicsBarChartItem()
if self._orientation == Qt.Horizontal:
self.chart.setAggregated(True)
self.chart.setSize(self.size())
self.scene.addItem(self.chart)
# Put all values to be shown in the records list
records = []
# Models could be None
if models:
# Fill in records with data from all models for all necessary fields.
# records will be a list of dictionaries:
# records = [
# { 'field1': value, 'field2': value }, #record 1
# { 'field1': value, 'field2': value } #record 2
# ...
# }
for m in models:
res = {}
for x in list(self._axisData.keys()):
type = self._fields[x]['type']
if type in ('many2one', 'char', 'time', 'text'):
res[x] = m.value(x)
elif type == 'selection':
res[x] = ''
for y in self._fields[x]['selection']:
if y[0] == m.value(x):
res[x] = str(y[1])
break
elif type == 'date':
if m.value(x):
date = time.strptime(m.value(x), DT_FORMAT)
res[x] = time.strftime(locale.nl_langinfo(
locale.D_FMT).replace('%y', '%Y'), date)
else:
res[x] = ''
elif type == 'datetime':
if m.value(x):
date = time.strptime(m.value(x), DHM_FORMAT)
if 'tz' in Rpc.session.context:
try:
import pytz
lzone = pytz.timezone(
Rpc.session.context['tz'])
szone = pytz.timezone(Rpc.session.timezone)
dt = datetime.datetime(
date[0], date[1], date[2], date[3], date[4], date[5], date[6])
sdt = szone.localize(dt, is_dst=True)
ldt = sdt.astimezone(lzone)
date = ldt.timetuple()
except:
pass
res[x] = time.strftime(locale.nl_langinfo(
locale.D_FMT).replace('%y', '%Y') + ' %H:%M:%S', date)
else:
res[x] = ''
else:
res[x] = float(m.value(x) or 0.0)
records.append(res)
# Calculate the rest of values
operators = {
'+': lambda x, y: x + y,
'*': lambda x, y: x * y,
'min': lambda x, y: min(x, y),
'max': lambda x, y: max(x, y),
'**': lambda x, y: x**y
}
# Fill in aggRecords (aggregated records). So it basically aggregates records
# appropiately. For example, a view may be defined:
#
# <graph string="Timesheet by user" type="bar">
# <field name="name"/>
# <field name="quantity" operator="+"/>
# <field group="True" name="user_id"/>
# </graph>
#
# So here we "execute" the operator="+" attribute. And the group tag.
aggRecords = []
groups = {}
for field in self._axis[1:]:
data = {}
for d in records:
data.setdefault(d[self._axis[0]], {})
groupEval = ','.join(self.replaceFalse(
[d[x] for x in self._groups]))
groups[groupEval] = 1
if groupEval in data[d[self._axis[0]]]:
oper = operators[self._axisData[field].get(
'operator', '+')]
data[d[self._axis[0]]][groupEval] = oper(
data[d[self._axis[0]]][groupEval], d[field])
else:
data[d[self._axis[0]]][groupEval] = d[field]
aggRecords.append(data)
groups = list(groups.keys())
groups.sort()
fields = set()
for field in self._axis[1:]:
fields.add(self._fields[field]['name'])
fields = list(fields)
fields.sort()
labels = [self._fields[x]['string'] for x in self._axis[1:]]
categories = set()
for x in records:
categories.add(x[self._axis[0]])
categories = list(categories)
categories.sort()
if self._type == 'pie':
categories = list(data.keys())
values = [reduce(lambda x, y=0: x + y, list(data[x].values()), 0)
for x in categories]
self.chart.setValues(values)
# Ensure all categories are strings
self.chart.setLabels(self.replaceFalse(categories))
else:
# Prepare values depending in different ways if there are 'group' tags in the
# view or not.
if groups and groups[0]:
# GTK client leaves only the last part with the following line:
# groups = [x.split('/')[-1] for x in groups]
# However that may remove important information. For example, in product types:
# 'Class A / Subclass A' -> 'Subclass A'
# 'Class B / Subclass A' -> 'Subclass A'
values = []
for x in categories:
value = []
for y in groups:
for z in aggRecords:
value.append(z[x].get(y, 0.0))
values.append(value)
# If we're grouping we need to change the labels
labels = groups
else:
values = []
for x in categories:
value = []
for y in aggRecords:
value.append(y[x][''])
values.append(value)
self.chart.setValues(values)
# Ensure all labels are strings
self.chart.setLabels(self.replaceFalse(labels))
# Ensure all categories are strings
self.chart.setCategories(self.replaceFalse(categories))
def load_lang(self, cr, uid, lang, lang_name=None):
# create the language with locale information
fail = True
iso_lang = tools.get_iso_codes(lang)
for ln in tools.get_locales(lang):
try:
locale.setlocale(locale.LC_ALL, str(ln))
fail = False
break
except locale.Error:
continue
if fail:
lc = locale.getdefaultlocale()[0]
msg = 'Unable to get information for locale %s. Information from the default locale (%s) have been used.'
_logger.warning(msg, lang, lc)
if not lang_name:
lang_name = tools.ALL_LANGUAGES.get(lang, lang)
def fix_xa0(s):
"""Fix badly-encoded non-breaking space Unicode character from locale.localeconv(),
coercing to utf-8, as some platform seem to output localeconv() in their system
encoding, e.g. Windows-1252"""
if s == '\xa0':
return '\xc2\xa0'
return s
def fix_datetime_format(format):
"""Python's strftime supports only the format directives
that are available on the platform's libc, so in order to
be 100% cross-platform we map to the directives required by
the C standard (1989 version), always available on platforms
with a C standard implementation."""
# For some locales, nl_langinfo returns a D_FMT/T_FMT that contains
# unsupported '%-' patterns, e.g. for cs_CZ
format = format.replace('%-', '%')
for pattern, replacement in tools.DATETIME_FORMATS_MAP.iteritems():
format = format.replace(pattern, replacement)
return str(format)
lang_info = {
'code': lang,
'iso_code': iso_lang,
'name': lang_name,
'translatable': 1,
'date_format':
fix_datetime_format(locale.nl_langinfo(locale.D_FMT)),
'time_format':
fix_datetime_format(locale.nl_langinfo(locale.T_FMT)),
'decimal_point':
fix_xa0(str(locale.localeconv()['decimal_point'])),
'thousands_sep':
fix_xa0(str(locale.localeconv()['thousands_sep'])),
}
lang_id = False
try:
lang_id = self.create(cr, uid, lang_info)
finally:
tools.resetlocale()
return lang_id
locale_encoding = 'ascii'
if sys.platform == 'win32':
# On Windows, we could use "mbcs". However, to give the user
# a portable encoding name, we need to find the code page
try:
locale_encoding = locale.getdefaultlocale()[1]
codecs.lookup(locale_encoding)
except LookupError:
pass
else:
try:
# Different things can fail here: the locale module may not be
# loaded, it may not offer nl_langinfo, or CODESET, or the
# resulting codeset may be unknown to Python. We ignore all
# these problems, falling back to ASCII
locale_encoding = locale.nl_langinfo(locale.CODESET)
if locale_encoding is None or locale_encoding is '':
# situation occurs on Mac OS X
locale_encoding = 'ascii'
codecs.lookup(locale_encoding)
except (NameError, AttributeError, LookupError):
# Try getdefaultlocale: it parses environment variables,
# which may give a clue. Unfortunately, getdefaultlocale has
# bugs that can cause ValueError.
try:
locale_encoding = locale.getdefaultlocale()[1]
if locale_encoding is None or locale_encoding is '':
# situation occurs on Mac OS X
locale_encoding = 'ascii'
codecs.lookup(locale_encoding)
except (ValueError, LookupError):
def get(self):
result = super(ComputerResource, self).get()
node_collection = self.request.db.nodes
if not result.get('node_chef_id', None):
return result
logger.info("/api/computers/: node_chef_id: %s" %
(str(result.get('node_chef_id', None))))
try:
api = get_chef_api(self.request.registry.settings,
self.request.user)
computer_node = ChefNode(result['node_chef_id'], api)
ohai = to_deep_dict(computer_node.attributes)
nodeid = result.get('_id', None)
usernames = [
i['username']
for i in ohai.get('ohai_gecos', {}).get('users', [])
]
users = list(
node_collection.find(
{
"$and": [{
"$or": [{
"name": {
"$in": usernames
}
}]
}, {
"type": "user"
}, {
"computers": {
"$elemMatch": {
"$eq": ObjectId(nodeid)
}
}
}]
}, {
'_id': 1,
'name': 1,
'path': 1
}))
# ObjectId to string for JSON serialize
[d.update({'_id': str(d['_id'])}) for d in users]
# Create a list of users that provides at least one user policy to this computer
users_inheritance_pre = list(
node_collection.find(
{
"$and": [{
"$or": [{
"name": {
"$in": usernames
}
}]
}, {
"type": "user"
}, {
"computers": {
"$elemMatch": {
"$eq": ObjectId(nodeid)
}
}
}]
}, {
'_id': 1,
'name': 1,
'path': 1,
'inheritance': 1
}))
[d.update({'_id': str(d['_id'])}) for d in users_inheritance_pre]
users_inheritance = []
for usr_inh in users_inheritance_pre:
if 'inheritance' in usr_inh:
policies_list = get_inheritance_tree_policies_list(
usr_inh['inheritance'], [])
if len(policies_list) > 0:
users_inheritance.append(usr_inh)
cpu = ohai.get('cpu', {}).get('0', {})
dmi = ohai.get('dmi', {})
# debug_mode flag for logs tab
debug_mode = False
try:
debug_mode = computer_node.attributes.get_dotted(
DEBUG_MODE_ENABLE_ATTR_PATH)
except KeyError:
pass
# Get logs info
logs_data = node_collection.find_one(
{
"type": "computer",
"_id": ObjectId(nodeid)
}, {"logs": True})
logs = {}
if logs_data is not None and 'logs' in logs_data:
logs_data = logs_data['logs']
date_format = locale.nl_langinfo(locale.D_T_FMT)
date = datetime.datetime(
*map(int,
re.split('[^\d]', logs_data['date'])[:-1]))
localename = locale.normalize(
get_current_request().locale_name + '.UTF-8')
logger.debug("/api/computers/: localename: %s" %
(str(localename)))
locale.setlocale(locale.LC_TIME, localename)
logs['date'] = date.strftime(date_format)
logger.debug("/api/computers/: date: %s" % (str(logs['date'])))
logs['files'] = logs_data['files']
for filedata in logs_data['files']:
# Do not send file contents
del filedata['content']
# Get Help Channel info
help_channel_enabled = True
helpchannel_data = self.request.db.helpchannel.find({
"computer_node_id":
result['node_chef_id']
}).sort([("last_modified", pymongo.DESCENDING)]).limit(6)
helpchannel = {}
helpchannel['current'] = None
helpchannel['last'] = []
if helpchannel_data is not None:
c = 0
for hcdata in helpchannel_data:
# Format date
date_format = locale.nl_langinfo(locale.D_T_FMT)
logger.info("last_modified: {0}".format(
hcdata['last_modified']))
last_mod = re.split('[^\d]', str(hcdata['last_modified']))
logger.info("last_mod: {0}".format(last_mod))
date = datetime.datetime(*map(int, last_mod[:-2]))
localename = locale.normalize(
get_current_request().locale_name + '.UTF-8')
logger.debug("/api/computers/: localename: %s" %
(str(localename)))
locale.setlocale(locale.LC_TIME, localename)
hcdata['last_modified'] = date.strftime(date_format)
if hcdata['user_node_id']:
# Format user
user_data = node_collection.find_one({
"type":
"user",
"_id":
ObjectId(hcdata['user_node_id'])
})
if user_data:
hcdata['user'] = user_data['name']
else:
logger.error("User not found: {0}".format(
hcdata['user_node_id']))
else:
hcdata['user'] = ''
if hcdata['adminuser_id']:
# Format user
user_data = self.request.db.adminusers.find_one(
{"_id": ObjectId(hcdata['adminuser_id'])})
if user_data:
hcdata['admin'] = user_data['username']
else:
logger.error("Admin user not found: {0}".format(
hcdata['adminuser_id']))
else:
hcdata['admin'] = ''
# Translate status info
hcdata['status'] = _('Unknown status')
if hcdata['action'] == 'request':
hcdata['status'] = _('User is requesting support')
elif hcdata['action'] == 'accepted':
hcdata['status'] = _('User is requesting support')
elif hcdata['action'] == 'finished user':
hcdata['status'] = _('Terminated by user')
elif hcdata['action'] == 'finished tech':
hcdata['status'] = _('Terminated by technician')
elif hcdata['action'] == 'finished error':
hcdata['status'] = _(
'Terminated because of a communication error')
elif hcdata['action'] == 'giving support':
hcdata['status'] = _(
'The technician is giving support to the user')
hcdata['_id'] = str(hcdata['_id'])
if (c == 0 and hcdata['action'] == 'accepted'):
helpchannel['current'] = hcdata
else:
helpchannel['last'].append(hcdata)
c = c + 1
result.update({
'ohai':
ohai,
'users':
users, # Users related with this computer
'users_inheritance':
users_inheritance, # Users related with this computer that provides at least one user policy
'uptime':
ohai.get('uptime', ''),
#'gcc_link': ohai.get('gcc_link',True),
'ipaddress':
ohai.get('ipaddress', ''),
'cpu':
'%s %s' %
(cpu.get('vendor_id', ''), cpu.get('model_name', '')),
'product_name':
dmi.get('system', {}).get('product_name', ''),
'manufacturer':
dmi.get('system', {}).get('manufacturer', ''),
'ram':
ohai.get('memory', {}).get('total', ''),
'lsb':
ohai.get('lsb', {}),
'kernel':
ohai.get('kernel', {}),
'filesystem':
ohai.get('filesystem', {}),
'debug_mode':
debug_mode,
'logs':
logs,
'helpchannel':
helpchannel,
'help_channel_enabled':
help_channel_enabled
})
except (urllib2.URLError, ChefError, ChefServerError):
logger.error(
"/api/computers/: error getting data: node_chef_id: %s " %
(str(result.get('node_chef_id', None))))
logger.error(traceback.format_exc())
return result
'%-M': 'FMMI', # Minute
'%S': 'SS', # zero padded second
'%-S': 'FMSS', # Second
'%f': 'US', # zero padded microsecond
'%z': 'OF', # utf offset
'%Z': 'TZ', # uppercase timezone name
'%j': 'DDD', # zero padded day of year
'%-j': 'FMDDD', # day of year
'%U': 'WW', # 1-based week of year
# 'W': ?, # meh
}
try:
_strftime_to_postgresql_rules.update({
'%c':
locale.nl_langinfo(locale.D_T_FMT), # locale date and time
'%x':
locale.nl_langinfo(locale.D_FMT), # locale date
'%X':
locale.nl_langinfo(locale.T_FMT), # locale time
})
except AttributeError:
warnings.warn(
'locale specific date formats (%%c, %%x, %%X) are not yet implemented '
'for %s' % platform.system())
# translate strftime spec into mostly equivalent PostgreSQL spec
_scanner = re.Scanner( # type: ignore # re does have a Scanner attribute
# double quotes need to be escaped
[('"', lambda *_: r'\"')] + [(
'|'.join(
def get_month_name(month): """Schreibt den Monatsnamen aus.""" if (month == 1): return locale.nl_langinfo(locale.MON_1) elif (month == 2): return locale.nl_langinfo(locale.MON_2) elif (month == 3): return locale.nl_langinfo(locale.MON_3) elif (month == 4): return locale.nl_langinfo(locale.MON_4) elif (month == 5): return locale.nl_langinfo(locale.MON_5) elif (month == 6): return locale.nl_langinfo(locale.MON_6) elif (month == 7): return locale.nl_langinfo(locale.MON_7) elif (month == 8): return locale.nl_langinfo(locale.MON_8) elif (month == 9): return locale.nl_langinfo(locale.MON_9) elif (month == 10): return locale.nl_langinfo(locale.MON_10) elif (month == 11): return locale.nl_langinfo(locale.MON_11) elif (month == 12): return locale.nl_langinfo(locale.MON_12)
def format_date(loc, d):
with switchlocale(loc):
fmt = locale.nl_langinfo(locale.D_T_FMT)
return d.strftime(fmt)
#!/usr/bin/env python
#
# Copyright 2007 Doug Hellmann.
#
"""Print dates in locale-specfic format.
"""
#end_pymotw_header
import locale
import time
sample_locales = [
('USA', 'en_US'),
('France', 'fr_FR'),
('Spain', 'es_ES'),
('Portugal', 'pt_PT'),
('Poland', 'pl_PL'),
]
for name, loc in sample_locales:
locale.setlocale(locale.LC_ALL, loc)
print '%20s: %s' % (name, time.strftime(locale.nl_langinfo(
locale.D_T_FMT)))
def internal_date_to_str(date, ifmt, fmt=locale.nl_langinfo(locale.D_FMT)):
date = datetime.datetime.strptime(date, ifmt)
return date_to_str(datetime.date(date.year, date.month, date.day), fmt)
* fuzzy is when a date is just a string not representing a real date
(like `someday`)
* date is a datetime.date accurate to the day (see datetime.date)
* datetime is a datetime.datetime accurate to the microseconds
(see datetime.datetime)
* timezone ia a datetime.datetime accurate to the microseconds with tzinfo
"""
fuzzy = 'fuzzy'
date = 'date'
datetime = 'datetime'
timezone = 'timezone'
# ISO 8601 date format
# get date format from locale
DATE_FORMATS = [(locale.nl_langinfo(locale.D_T_FMT), Accuracy.datetime),
('%Y-%m-%dT%H:%M%S.%f%z', Accuracy.timezone),
('%Y-%m-%d %H:%M%S.%f%z', Accuracy.timezone),
('%Y-%m-%dT%H:%M%S.%f', Accuracy.datetime),
('%Y-%m-%d %H:%M%S.%f', Accuracy.datetime),
('%Y-%m-%dT%H:%M%S', Accuracy.datetime),
('%Y-%m-%d %H:%M%S', Accuracy.datetime),
(locale.nl_langinfo(locale.D_FMT), Accuracy.date),
('%Y-%m-%d', Accuracy.date)]
class Date:
"""A date class that supports fuzzy dates.
A Date can be constructed with:
- the fuzzy strings 'now', 'soon', '' (no date, default), or 'someday'
date_fmt = plugins['usbobserver'][0].date_format()
parse_date_day_first = date_fmt.index(u'd') < date_fmt.index(u'M')
except:
parse_date_day_first = False
else:
try:
def first_index(raw, queries):
for q in queries:
try:
return raw.index(q)
except ValueError:
pass
return -1
import locale
raw = locale.nl_langinfo(locale.D_FMT)
parse_date_day_first = first_index(raw, ('%d', '%a', '%A')) < first_index(raw, ('%m', '%b', '%B'))
del raw, first_index
except:
parse_date_day_first = False
UNDEFINED_DATE = datetime(101,1,1, tzinfo=utc_tz)
DEFAULT_DATE = datetime(2000,1,1, tzinfo=utc_tz)
EPOCH = datetime(1970, 1, 1, tzinfo=_utc_tz)
def is_date_undefined(qt_or_dt):
d = qt_or_dt
if d is None:
return True
if hasattr(d, 'toString'):
if hasattr(d, 'date'):
def strtime(self, secs):
try:
from locale import nl_langinfo, D_T_FMT
return time.strftime(nl_langinfo(D_T_FMT), time.localtime(secs))
except ImportError, ValueError:
return time.ctime(secs)
def resolve_date_format(year, month, day, fail_safe=True):
"""
Puts the year, month and day objects in the right order according to the
currently set locale and provides format specification for each of the
fields.
:param year: any object or value representing year
:type year: any
:param month: any object or value representing month
:type month: any
:param day: any object or value representing day
:type day: any
:param bool fail_safe: whether to fall back to default in case of invalid
format or raise exception instead
:returns: a pair where the first field contains a tuple with the year, month
and day objects/values put in the right order and where the second
field contains a tuple with three :class:`_DateFieldSpec` objects
specifying formats respectively to the first (year, month, day)
field, e.g. ((year, month, day), (y_fmt, m_fmt, d_fmt))
:rtype: tuple
:raise ValueError: in case currently set locale has unsupported date
format and fail_safe is set to False
"""
FAIL_SAFE_DEFAULT = "%Y-%m-%d"
def order_terms_formats(fmt_str):
# see date (1), 'O' (not '0') is a mystery, 'E' is Buddhist calendar, '(.*)'
# is an arbitrary suffix
field_spec_re = re.compile(r'([-_0OE^#]*)([yYmbBde])(.*)')
# see date (1)
fmt_str = fmt_str.replace("%F", "%Y-%m-%d")
# e.g. "%d.%m.%Y" -> ['d.', 'm.', 'Y']
fields = fmt_str.split("%")[1:]
ordered_terms = []
ordered_formats = []
for field in fields:
match = field_spec_re.match(field)
if not match:
# ignore fields we are not interested in (like %A for weekday name, etc.)
continue
prefix, item, suffix = match.groups()
if item in ("d", "e"):
# "e" is the same as "_d"
ordered_terms.append(day)
elif item in ("Y", "y"):
# 4-digit year, 2-digit year
ordered_terms.append(year)
elif item in ("m", "b", "B"):
# month number, short month name, long month name
ordered_terms.append(month)
# "%" + prefix + item gives a format for date/time formatting functions
ordered_formats.append(
_DateFieldSpec("%" + prefix + item, suffix.strip()))
if len(ordered_terms) != 3 or len(ordered_formats) != 3:
raise ValueError(
"Not all fields successfully identified in the format '%s'" %
fmt_str)
return (tuple(ordered_terms), tuple(ordered_formats))
fmt_str = locale_mod.nl_langinfo(locale_mod.D_FMT)
if not fmt_str or "%" not in fmt_str:
if fail_safe:
# use some sane default
fmt_str = FAIL_SAFE_DEFAULT
else:
raise ValueError(
"Invalid date format string for current locale: '%s'" %
fmt_str)
try:
return order_terms_formats(fmt_str)
except ValueError:
if not fail_safe:
raise
else:
# if this call fails too, something is going terribly wrong and we
# should be informed about it
return order_terms_formats(FAIL_SAFE_DEFAULT)
def writeScript(self, expPath=None, target="PsychoPy"):
"""Write a PsychoPy script for the experiment
"""
self.flow._prescreenValues()
self.expPath = expPath
script = IndentingBuffer(u'') # a string buffer object
# get date info, in format preferred by current locale as set by app:
if hasattr(locale, 'nl_langinfo'):
fmt = locale.nl_langinfo(locale.D_T_FMT)
localDateTime = data.getDateStr(format=fmt)
else:
localDateTime = data.getDateStr(format="%B %d, %Y, at %H:%M")
if target == "PsychoPy":
self.settings.writeInitCode(script, self.psychopyVersion,
localDateTime)
self.settings.writeStartCode(script) # present info, make logfile
# writes any components with a writeStartCode()
self.flow.writeStartCode(script)
self.settings.writeWindowCode(script) # create our visual.Window()
# for JS the routine begin/frame/end code are funcs so write here
# write the rest of the code for the components
self.flow.writeBody(script)
self.settings.writeEndCode(script) # close log file
elif target == "PsychoJS":
script.oneIndent = " " # use 2 spaces rather than python 4
self.settings.writeInitCodeJS(script, self.psychopyVersion,
localDateTime)
self.settings.writeWindowCodeJS(script)
# initialise the components for all Routines in a single function
script.writeIndentedLines("\nfunction experimentInit() {")
script.setIndentLevel(1, relative=True)
# routine init sections
for entry in self.flow:
# NB each entry is a routine or LoopInitiator/Terminator
self._currentRoutine = entry
if hasattr(entry, 'writeInitCodeJS'):
entry.writeInitCodeJS(script)
# create globalClock etc
code = ("\n// Create some handy timers\n"
"globalClock = new psychoJS.core.Clock();"
" // to track the time since experiment started\n"
"routineTimer = new psychoJS.core.CountdownTimer();"
" // to track time remaining of each (non-slip) routine\n"
"\nreturn psychoJS.NEXT;")
script.writeIndentedLines(code)
script.setIndentLevel(-1, relative=True)
script.writeIndentedLines("}")
# This differs to the Python script. We can loop through all
# Routines once (whether or not they get used) because we're using
# functions that may or may not get called later.
# Do the Routines of the experiment first
for thisRoutine in list(self.routines.values()):
self._currentRoutine = thisRoutine
thisRoutine.writeRoutineBeginCodeJS(script)
thisRoutine.writeEachFrameCodeJS(script)
thisRoutine.writeRoutineEndCodeJS(script)
# loao resources files (images, csv files etc
self.flow.writeResourcesCodeJS(script)
# create the run() function and schedulers
self.flow.writeBodyJS(
script) # functions for loops and for scheduler
self.settings.writeEndCodeJS(script)
return script
def _str_to_decimal(num_str):
radix = locale.nl_langinfo(locale.RADIXCHAR)
if radix != '.':
num_str = num_str.replace(radix, '.')
return Decimal(num_str)
def _get_human_time(self, timestamp):
fmt = locale.nl_langinfo(locale.D_T_FMT)
return datetime.datetime.fromtimestamp(timestamp).strftime(fmt)
def get_date(self):
return self.added.strftime(locale.nl_langinfo(locale.D_T_FMT))
def _show_changes(self):
def show_packages(pkgs):
"""Format the pkgs in a nice way."""
line = " "
pkgs.sort()
for pkg in pkgs:
try:
name, version = pkg.split("=", 1)[0:2]
except ValueError:
name = pkg
version = None
if self._details and version:
output = "%s=%s" % (name, version)
else:
output = name
if (len(line) + 1 + len(output) > self._terminal_width
and line != " "):
print(line)
line = " "
line += " %s" % output
if line != " ":
print(line)
self._stop_custom_progress()
self._clear_progress()
(installs, reinstalls, removals, purges, upgrades,
downgrades) = self._transaction.packages
(dep_installs, dep_reinstalls, dep_removals, dep_purges, dep_upgrades,
dep_downgrades, dep_kepts) = self._transaction.dependencies
installs.extend(dep_installs)
upgrades.extend(dep_upgrades)
removals.extend(purges)
removals.extend(dep_removals)
removals.extend(dep_purges)
reinstalls.extend(dep_reinstalls)
downgrades.extend(dep_downgrades)
kepts = dep_kepts
if installs:
# TRANSLATORS: %s is the number of packages
print((ngettext(
"The following NEW package will be installed "
"(%(count)s):", "The following NEW packages will be installed "
"(%(count)s):", len(installs)) % {
"count": len(installs)
}))
show_packages(installs)
if upgrades:
# TRANSLATORS: %s is the number of packages
print((ngettext(
"The following package will be upgraded "
"(%(count)s):", "The following packages will be upgraded "
"(%(count)s):", len(upgrades)) % {
"count": len(upgrades)
}))
show_packages(upgrades)
if removals:
# TRANSLATORS: %s is the number of packages
print((ngettext(
"The following package will be REMOVED "
"(%(count)s):", "The following packages will be REMOVED "
"(%(count)s):", len(removals)) % {
"count": len(removals)
}))
# FIXME: mark purges
show_packages(removals)
if downgrades:
# TRANSLATORS: %s is the number of packages
print((ngettext(
"The following package will be DOWNGRADED "
"(%(count)s):", "The following packages will be DOWNGRADED "
"(%(count)s):", len(downgrades)) % {
"count": len(downgrades)
}))
show_packages(downgrades)
if reinstalls:
# TRANSLATORS: %s is the number of packages
print((ngettext(
"The following package will be reinstalled "
"(%(count)s):", "The following packages will be reinstalled "
"(%(count)s):", len(reinstalls)) % {
"count": len(reinstalls)
}))
show_packages(reinstalls)
if kepts:
print((ngettext(
"The following package has been kept back "
"(%(count)s):", "The following packages have been kept back "
"(%(count)s):", len(kepts)) % {
"count": len(kepts)
}))
show_packages(kepts)
if self._transaction.download:
print(
_("Need to get %sB of archives.") %
client.get_size_string(self._transaction.download))
if self._transaction.space > 0:
print(
_("After this operation, %sB of additional disk space "
"will be used.") %
client.get_size_string(self._transaction.space))
elif self._transaction.space < 0:
print(
_("After this operation, %sB of additional disk space "
"will be freed.") %
client.get_size_string(self._transaction.space))
if (self._transaction.space or self._transaction.download or installs
or upgrades or downgrades or removals or kepts or reinstalls):
try:
if PY3K:
cont = input(_("Do you want to continue [Y/n]?"))
else:
cont = raw_input(_("Do you want to continue [Y/n]?"))
except EOFError:
cont = "n"
# FIXME: Listen to changed dependencies!
if (not re.match(locale.nl_langinfo(locale.YESEXPR), cont)
and cont != ""):
msg = enums.get_exit_string_from_enum(enums.EXIT_CANCELLED)
self._update_custom_progress(msg, None, False)
self._loop.quit()
sys.exit(1)
# TRANSLATORS: status message
self._progress_id = GLib.timeout_add(250, self._update_custom_progress,
_("Queuing"))
self._transaction.run(
error_handler=self._on_exception,
reply_handler=lambda: self._stop_custom_progress())
def main():
if locale.nl_langinfo(locale.CODESET).upper() not in ['US-ASCII', 'UTF-8']:
print(
"asciinema needs an ASCII or UTF-8 character encoding to run. Check the output of `locale` command."
)
sys.exit(1)
try:
cfg = config.load()
except config.ConfigError as e:
sys.stderr.write(str(e) + '\n')
sys.exit(1)
# create the top-level parser
parser = argparse.ArgumentParser(
description="Record and share your terminal sessions, the right way.",
epilog="""example usage:
Record terminal and upload it to asciinema.org:
\x1b[1masciinema rec\x1b[0m
Record terminal to local file:
\x1b[1masciinema rec demo.cast\x1b[0m
Record terminal and upload it to asciinema.org, specifying title:
\x1b[1masciinema rec -t "My git tutorial"\x1b[0m
Record terminal to local file, limiting idle time to max 2.5 sec:
\x1b[1masciinema rec -i 2.5 demo.cast\x1b[0m
Replay terminal recording from local file:
\x1b[1masciinema play demo.cast\x1b[0m
Replay terminal recording hosted on asciinema.org:
\x1b[1masciinema play https://asciinema.org/a/difqlgx86ym6emrmd8u62yqu8\x1b[0m
Print full output of recorded session:
\x1b[1masciinema cat demo.cast\x1b[0m
For help on a specific command run:
\x1b[1masciinema <command> -h\x1b[0m""",
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument('--version',
action='version',
version='asciinema %s' % __version__)
subparsers = parser.add_subparsers()
# create the parser for the "rec" command
parser_rec = subparsers.add_parser('rec', help='Record terminal session')
parser_rec.add_argument('--stdin',
help='enable stdin recording, disabled by default',
action='store_true',
default=cfg.record_stdin)
parser_rec.add_argument('--append',
help='append to existing recording',
action='store_true',
default=False)
parser_rec.add_argument('--raw',
help='save only raw stdout output',
action='store_true',
default=False)
parser_rec.add_argument('--overwrite',
help='overwrite the file if it already exists',
action='store_true',
default=False)
parser_rec.add_argument('-c',
'--command',
help='command to record, defaults to $SHELL',
default=cfg.record_command)
parser_rec.add_argument(
'-e',
'--env',
help='list of environment variables to capture, defaults to ' +
config.DEFAULT_RECORD_ENV,
default=cfg.record_env)
parser_rec.add_argument('-t', '--title', help='title of the asciicast')
parser_rec.add_argument(
'-i',
'--idle-time-limit',
help='limit recorded idle time to given number of seconds',
type=positive_float,
default=maybe_str(cfg.record_idle_time_limit))
parser_rec.add_argument(
'-y',
'--yes',
help='answer "yes" to all prompts (e.g. upload confirmation)',
action='store_true',
default=cfg.record_yes)
parser_rec.add_argument(
'-q',
'--quiet',
help='be quiet, suppress all notices/warnings (implies -y)',
action='store_true',
default=cfg.record_quiet)
parser_rec.add_argument('filename',
nargs='?',
default='',
help='filename/path to save the recording to')
parser_rec.set_defaults(func=rec_command)
# create the parser for the "play" command
parser_play = subparsers.add_parser('play', help='Replay terminal session')
parser_play.add_argument(
'-i',
'--idle-time-limit',
help='limit idle time during playback to given number of seconds',
type=positive_float,
default=maybe_str(cfg.play_idle_time_limit))
parser_play.add_argument('-s',
'--speed',
help='playback speedup (can be fractional)',
type=positive_float,
default=cfg.play_speed)
parser_play.add_argument(
'filename', help='local path, http/ipfs URL or "-" (read from stdin)')
parser_play.set_defaults(func=play_command)
# create the parser for the "cat" command
parser_cat = subparsers.add_parser(
'cat', help='Print full output of terminal session')
parser_cat.add_argument(
'filename', help='local path, http/ipfs URL or "-" (read from stdin)')
parser_cat.set_defaults(func=cat_command)
# create the parser for the "upload" command
parser_upload = subparsers.add_parser(
'upload',
help='Upload locally saved terminal session to asciinema.org')
parser_upload.add_argument('filename',
help='filename or path of local recording')
parser_upload.set_defaults(func=upload_command)
# create the parser for the "auth" command
parser_auth = subparsers.add_parser(
'auth', help='Manage recordings on asciinema.org account')
parser_auth.set_defaults(func=auth_command)
# parse the args and call whatever function was selected
args = parser.parse_args()
if hasattr(args, 'func'):
command = args.func(args, cfg)
code = command.execute()
sys.exit(code)
else:
parser.print_help()
sys.exit(1)
def print_formatted(
self,
fp=sys.stdout,
force_color=False,
no_color=False,
show_cmd=False,
show_full_cmd=False,
show_user=False,
show_pid=False,
show_power=None,
show_fan_speed=None,
gpuname_width=16,
show_header=True,
eol_char=os.linesep,
):
# ANSI color configuration
if force_color and no_color:
raise ValueError("--color and --no_color can't"
" be used at the same time")
if force_color:
t_color = Terminal(kind='linux', force_styling=True)
# workaround of issue #32 (watch doesn't recognize sgr0 characters)
t_color.normal = u'\x1b[0;10m'
elif no_color:
t_color = Terminal(force_styling=None)
else:
t_color = Terminal() # auto, depending on isatty
# appearance settings
entry_name_width = [len(g.entry['name']) for g in self]
gpuname_width = max([gpuname_width or 0] + entry_name_width)
# header
if show_header:
time_format = locale.nl_langinfo(locale.D_T_FMT)
header_template = '{t.bold_white}{hostname:{width}}{t.normal} '
header_template += '{timestr} '
header_template += '{t.bold_black}{driver_version}{t.normal}'
header_msg = header_template.format(
hostname=self.hostname,
width=gpuname_width + 3, # len("[?]")
timestr=self.query_time.strftime(time_format),
driver_version=self.driver_version,
t=t_color,
)
fp.write(header_msg.strip())
fp.write(eol_char)
# body
for g in self:
g.print_to(fp,
show_cmd=show_cmd,
show_full_cmd=show_full_cmd,
show_user=show_user,
show_pid=show_pid,
show_power=show_power,
show_fan_speed=show_fan_speed,
gpuname_width=gpuname_width,
term=t_color)
fp.write(eol_char)
fp.flush()
def __log_locale_settings(message=None):
_setlocale_categories = {}
for category in 'LC_ALL LC_CTYPE LC_NUMERIC LC_TIME LC_COLLATE LC_MONETARY LC_MESSAGES LC_PAPER LC_NAME LC_ADDRESS LC_TELEPHONE LC_MEASUREMENT LC_IDENTIFICATION'.split(
):
try:
_setlocale_categories[category] = getattr(locale, category)
except Exception:
_log.warning('this OS does not have locale.%s', category)
_getlocale_categories = {}
for category in 'LC_CTYPE LC_NUMERIC LC_TIME LC_COLLATE LC_MONETARY LC_MESSAGES LC_PAPER LC_NAME LC_ADDRESS LC_TELEPHONE LC_MEASUREMENT LC_IDENTIFICATION'.split(
):
try:
_getlocale_categories[category] = getattr(locale, category)
except Exception:
pass
if message is not None:
_log.debug(message)
_log.debug('current locale settings:')
_log.debug('locale.getlocale(): %s' % str(locale.getlocale()))
for category in _getlocale_categories:
_log.debug(
'locale.getlocale(%s): %s' %
(category, locale.getlocale(_getlocale_categories[category])))
for category in _setlocale_categories:
_log.debug(
'(locale.setlocale(%s): %s)' %
(category, locale.setlocale(_setlocale_categories[category])))
try:
_log.debug('locale.getdefaultlocale() - default (user) locale: %s' %
str(locale.getdefaultlocale()))
except ValueError:
_log.exception('the OS locale setup seems faulty')
_log.debug(
'encoding sanity check (also check "locale.nl_langinfo(CODESET)" below):'
)
pref_loc_enc = locale.getpreferredencoding(do_setlocale=False)
loc_enc = locale.getlocale()[1]
py_str_enc = sys.getdefaultencoding()
sys_fs_enc = sys.getfilesystemencoding()
_log.debug('sys.getdefaultencoding(): [%s]' % py_str_enc)
_log.debug('locale.getpreferredencoding(): [%s]' % pref_loc_enc)
_log.debug('locale.getlocale()[1]: [%s]' % loc_enc)
_log.debug('sys.getfilesystemencoding(): [%s]' % sys_fs_enc)
if loc_enc is not None:
loc_enc = loc_enc.upper()
loc_enc_compare = loc_enc.replace('-', '')
else:
loc_enc_compare = loc_enc
if pref_loc_enc.upper().replace('-', '') != loc_enc_compare:
_log.warning(
'encoding suggested by locale (%s) does not match encoding currently set in locale (%s)'
% (pref_loc_enc, loc_enc))
_log.warning('this might lead to encoding errors')
for enc in [pref_loc_enc, loc_enc, py_str_enc, sys_fs_enc]:
if enc is not None:
try:
codecs.lookup(enc)
_log.debug('<codecs> module CAN handle encoding [%s]' % enc)
except LookupError:
_log.warning('<codecs> module can NOT handle encoding [%s]' %
enc)
_log.debug(
'on Linux you can determine a likely candidate for the encoding by running "locale charmap"'
)
_log.debug(
'locale related environment variables (${LANG} is typically used):')
for var in 'LANGUAGE LC_ALL LC_CTYPE LANG'.split():
try:
_log.debug('${%s}=%s' % (var, os.environ[var]))
except KeyError:
_log.debug('${%s} not set' % (var))
_log.debug('database of locale conventions:')
data = locale.localeconv()
for key in data:
if loc_enc is None:
_log.debug('locale.localeconv(%s): %s', key, data[key])
else:
try:
_log.debug('locale.localeconv(%s): %s', key, str(data[key]))
except UnicodeDecodeError:
_log.debug('locale.localeconv(%s): %s', key,
str(data[key], loc_enc))
_nl_langinfo_categories = {}
for category in 'CODESET D_T_FMT D_FMT T_FMT T_FMT_AMPM RADIXCHAR THOUSEP YESEXPR NOEXPR CRNCYSTR ERA ERA_D_T_FMT ERA_D_FMT ALT_DIGITS'.split(
):
try:
_nl_langinfo_categories[category] = getattr(locale, category)
except Exception:
_log.warning(
'this OS does not support nl_langinfo category locale.%s' %
category)
try:
for category in _nl_langinfo_categories:
if loc_enc is None:
_log.debug(
'locale.nl_langinfo(%s): %s' %
(category,
locale.nl_langinfo(_nl_langinfo_categories[category])))
else:
try:
_log.debug(
'locale.nl_langinfo(%s): %s', category,
str(
locale.nl_langinfo(
_nl_langinfo_categories[category])))
except UnicodeDecodeError:
_log.debug(
'locale.nl_langinfo(%s): %s', category,
str(
locale.nl_langinfo(
_nl_langinfo_categories[category]), loc_enc))
except Exception:
_log.exception('this OS does not support nl_langinfo')
_log.debug('gmI18N.get_encoding(): %s', get_encoding())
def load_lang(self, lang, lang_name=None):
""" Create the given language if necessary, and make it active. """
# if the language exists, simply make it active
language = self.with_context(active_test=False).search(
[('code', '=', lang)], limit=1)
if language:
language.write({'active': True})
return language.id
# create the language with locale information
fail = True
iso_lang = tools.get_iso_codes(lang)
for ln in tools.get_locales(lang):
try:
locale.setlocale(locale.LC_ALL, str(ln))
fail = False
break
except locale.Error:
continue
if fail:
lc = locale.getdefaultlocale()[0]
msg = 'Unable to get information for locale %s. Information from the default locale (%s) have been used.'
_logger.warning(msg, lang, lc)
if not lang_name:
lang_name = lang
def fix_xa0(s):
"""Fix badly-encoded non-breaking space Unicode character from locale.localeconv(),
coercing to utf-8, as some platform seem to output localeconv() in their system
encoding, e.g. Windows-1252"""
if s == '\xa0':
return '\xc2\xa0'
return s
def fix_datetime_format(format):
"""Python's strftime supports only the format directives
that are available on the platform's libc, so in order to
be 100% cross-platform we map to the directives required by
the C standard (1989 version), always available on platforms
with a C standard implementation."""
# For some locales, nl_langinfo returns a D_FMT/T_FMT that contains
# unsupported '%-' patterns, e.g. for cs_CZ
format = format.replace('%-', '%')
for pattern, replacement in tools.DATETIME_FORMATS_MAP.items():
format = format.replace(pattern, replacement)
return str(format)
conv = locale.localeconv()
lang_info = {
'code': lang,
'iso_code': iso_lang,
'name': lang_name,
'active': True,
'date_format':
fix_datetime_format(locale.nl_langinfo(locale.D_FMT)),
'time_format':
fix_datetime_format(locale.nl_langinfo(locale.T_FMT)),
'decimal_point': fix_xa0(str(conv['decimal_point'])),
'thousands_sep': fix_xa0(str(conv['thousands_sep'])),
'grouping': str(conv.get('grouping', [])),
}
try:
return self.create(lang_info).id
finally:
tools.resetlocale()
