/usr/lib/python2.7/dist-packages/dispcalGUI/encodedstdio.py is in dispcalgui 1.7.1.6-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 | # -*- coding: utf-8 -*-
import codecs
import locale
import os
import sys
from encoding import get_encoding
_codecs = {}
_stdio = {}
def codec_register_alias(alias, name):
""" Register an alias for encoding 'name' """
_codecs[alias] = codecs.CodecInfo(name=alias,
encode=codecs.getencoder(name),
decode=codecs.getdecoder(name),
incrementalencoder=codecs.getincrementalencoder(name),
incrementaldecoder=codecs.getincrementaldecoder(name),
streamwriter=codecs.getwriter(name),
streamreader=codecs.getreader(name))
def conditional_decode(text, encoding='UTF-8', errors='strict'):
""" Decode text if not unicode """
if not isinstance(text, unicode):
text = text.decode(encoding, errors)
return text
def conditional_encode(text, encoding='UTF-8', errors='strict'):
""" Encode text if unicode """
if isinstance(text, unicode):
text = text.encode(encoding, errors)
return text
def encodestdio(encodings=None, errors=None):
""" After this function is called, Unicode strings written to
stdout/stderr are automatically encoded and strings read from stdin
automatically decoded with the given encodings and error handling.
encodings and errors can be a dict with mappings for stdin/stdout/stderr,
e.g. encodings={'stdin': 'UTF-8', 'stdout': 'UTF-8', 'stderr': 'UTF-8'}
or errors={'stdin': 'strict', 'stdout': 'replace', 'stderr': 'replace'}
In the case of errors, stdin uses a default 'strict' error handling and
stdout/stderr both use 'replace'.
"""
if not encodings:
encodings = {'stdin': None, 'stdout': None, 'stderr': None}
if not errors:
errors = {'stdin': 'strict', 'stdout': 'replace', 'stderr': 'replace'}
for stream_name in set(encodings.keys() + errors.keys()):
stream = getattr(sys, stream_name)
encoding = encodings.get(stream_name)
if not encoding:
encoding = get_encoding(stream)
error_handling = errors.get(stream_name, 'strict')
if isinstance(stream, EncodedStream):
stream.encoding = encoding
stream.errors = error_handling
else:
setattr(sys, stream_name, EncodedStream(stream, encoding,
error_handling))
def read(stream, size=-1):
""" Read from stream. Uses os.read() if stream is a tty,
stream.read() otherwise. """
if stream.isatty():
data = os.read(stream.fileno(), size)
else:
data = stream.read(size)
return data
def write(stream, data):
""" Write to stream. Uses os.write() if stream is a tty,
stream.write() otherwise. """
if stream.isatty():
os.write(stream.fileno(), data)
else:
stream.write(data)
class EncodedStream(object):
""" Unicode strings written to an EncodedStream are automatically encoded
and strings read from it automtically decoded with the given encoding
and error handling.
Uses os.read() and os.write() for proper handling of unicode codepages
for stdout/stderr under Windows """
def __init__(self, stream, encoding='UTF-8', errors='strict'):
self.stream = stream
self.encoding = encoding
self.errors = errors
def __getattr__(self, name):
return getattr(self.stream, name)
def __iter__(self):
return iter(self.readlines())
def __setattr__(self, name, value):
if name == 'softspace':
setattr(self.stream, name, value)
else:
object.__setattr__(self, name, value)
def next(self):
return self.readline()
def read(self, size=-1):
return conditional_decode(read(self.stream, size), self.encoding,
self.errors)
def readline(self, size=-1):
return conditional_decode(self.stream.readline(size), self.encoding,
self.errors)
def readlines(self, size=-1):
return [conditional_decode(line, self.encoding, self.errors)
for line in self.stream.readlines(size)]
def xreadlines(self):
return self
def write(self, text):
write(self.stream, conditional_encode(text, self.encoding, self.errors))
def writelines(self, lines):
for line in lines:
self.write(line)
# Store references to original stdin/stdout/stderr
for _stream_name in ('stdin', 'stdout', 'stderr'):
_stream = getattr(sys, _stream_name)
if isinstance(_stream, EncodedStream):
_stdio[_stream_name] = _stream.stream
else:
_stdio[_stream_name] = _stream
# Register codec aliases for codepages 65000 and 65001
codec_register_alias('65000', 'utf_7')
codec_register_alias('65001', 'utf_8')
codec_register_alias('cp65000', 'utf_7')
codec_register_alias('cp65001', 'utf_8')
codecs.register(lambda alias: _codecs.get(alias))
if __name__ == '__main__':
test = u'test \u00e4\u00f6\u00fc\ufffe test'
try:
print test
except (LookupError, IOError, UnicodeError), exception:
print 'could not print %r:' % test, exception
print 'wrapping stdout/stderr via encodestdio()'
encodestdio()
print test
print 'exiting normally'
|