def encode(self, input, final=False):
if self.first:
self.first = 0
return codecs.BOM_UTF8 + \
codecs.utf_8_encode(input, self.errors)[0]
else:
return codecs.utf_8_encode(input, self.errors)[0]
def write(self, message):
"""Write a message to the output stream."""
message = self.encoder.encode(message)
self.out.write(utf_8_encode(message)[0])
self.out.write(utf_8_encode('\n// END\n')[0])
self.out.flush()
def Instructions(self,myfsm):
self.score_to_win=500
base.setBackgroundColor(0,0,0)
for i in self.items:
i.destroy()
self.logo = OnscreenImage(image = 'models/BG_Screen01.jpg', pos = (0,0,0), scale=1.5)
font = loader.loadFont('fonts/PLUMP.TTF')
self.accept("s", myfsm.request, ["Game", self.level])
self.accept("escape", sys.exit)
self.logo2= OnscreenImage(image = 'models/Normal.png', pos = (-1.25,0,0.3), scale=0.115)
self.logo3= OnscreenImage(image = 'models/mayor.png', pos = (-1.25,0.0,0), scale=0.115)
self.logo4= OnscreenImage(image = 'models/Dorothy.png', pos = (-1.25,0,-0.3), scale=0.115)
self.tx = OnscreenText(text=(codecs.utf_8_encode("To complete this level you must get "+"\n"+str(self.score_to_win)+" points")[0]), fg=(1,0.7,0.4,1), scale = 0.09, pos=(0,0.7),font=font, shadow= (0,0,0,1))
self.tx1= OnscreenText(text=(codecs.utf_8_encode("One normal house gives you 50 points"+"\n"+"\n"+"\n"+"\n"+
"The mayor house gives you 100 points"+"\n"+"\n"+"\n"+"\n"+
"The Dorothy house gives you 200 points"+"\n"+"\n"+"\n"+"\n")[0]), fg=(1,0.7,0.4,1), scale = 0.07, pos=(0,0.3),font=font, shadow= (0,0,0,1))
self.tx2 = OnscreenText(text=(codecs.utf_8_encode("PLEASE WOODY, SAVE THE VILLAGE!!!")[0]), fg=(1,0.7,0.4,1), scale = 0.1, pos=(0,-0.65),font=font, shadow= (0,0,0,1))
self.tx3 = OnscreenText(text=(codecs.utf_8_encode("S: start game - P: previous - ESC: Exit")[0]), fg=(0.76,0.21,0,02), scale = 0.065, pos=(0,-0.87),font=font, shadow= (0,0,0,1))
self.items.append(self.tx)
self.items.append(self.tx2)
self.items.append(self.tx3)
self.items.append(self.tx1)
self.items.append(self.logo)
self.items.append(self.logo2)
self.items.append(self.logo3)
self.items.append(self.logo4)
def _buffer_encode_codepoint(self, input, final):
# Find the next byte position that indicates a variant of UTF-8.
# CESU-8 sequences always start with 0xed,
# Java nulls always start with 0xc0.
index1 = 0
try:
while ord(input[index1]) <= 0xffff:
index1 += 1
except IndexError:
index1 = -1
index2 = input.find('\x00')
# Set `index` to whichever index comes first.
if index1 != -1 and index2 != -1:
index = min(index1, index2)
elif index1 != -1:
index = index1
elif index2 != -1:
index = index2
else:
# No special characters found; encode the remaining
# input as standard UTF-8
return codecs.utf_8_encode(input, self.errors)
if index1 == 0:
# Encode a six-byte sequence starting with 0xed.
print([
0xED,
0xA0 | (((ord(input[0]) >> 16) - 1) & 0x0f),
0x80 | ((ord(input[0]) >> 10) & 0x3f),
0xED,
0xB0 | ((ord(input[0]) >> 6) & 0x0f),
0x80 | (ord(input[0]) & 0x3f),
])
return bytes(bytearray([
0xED,
0xA0 | (((ord(input[0]) >> 16) - 1) & 0x0f),
0x80 | ((ord(input[0]) >> 10) & 0x3f),
0xED,
0xB0 | ((ord(input[0]) >> 6) & 0x0f),
0x80 | (ord(input[0]) & 0x3f),
])), 1
elif index2 == 0:
# Encode a two-byte sequence, 0xc0 0x80.
return b'\xc0\x80', 1
else:
# Encode the bytes up until the next weird thing as UTF-8.
return codecs.utf_8_encode(input[:index], self.errors)
def save_il_to_word_cloud_file(word_cloud_file,int_scores_il,vocab_size,float_score=False,tagged=False,utf8=False,small_font_size=.3,large_font_size=7,call_R=False):
"""
Use the item list C{int_scores_il} to print out
save this string in the file R_Batch_file
If call_R = True, call R wordcloud package on wordcloud file
"""
ctr = 0
word_set = set()
with open(word_cloud_file,'w') as ofh:
print >> ofh, '"Word" "Score"'
for (i,w) in enumerate(int_scores_il):
if i == vocab_size:
break
s=int_scores_il[w]
if utf8:
w = codecs.utf_8_encode(w)[0]
if w in word_set:
continue
else:
ctr += 1
word_set.add(w)
if float_score:
print >> ofh, '"%d" "%s" %.8f' % (ctr,w,s)
else:
print >> ofh, '"%d" "%s" %d' % (ctr,w,s)
if call_R:
call_R_on_wordcloud_file (word_cloud_file,small_font_size,large_font_size)
def remember(self, environ, identity):
if self.include_ip:
remote_addr = environ['REMOTE_ADDR']
else:
remote_addr = '0.0.0.0'
cookies = get_cookies(environ)
old_cookie = cookies.get(self.cookie_name)
existing = cookies.get(self.cookie_name)
old_cookie_value = getattr(existing, 'value', None)
timestamp, userid, tokens, userdata = None, '', (), ''
if old_cookie_value:
validation = validateTicket(self.secret, old_cookie_value,
remote_addr, timeout=self.timeout,
mod_auth_tkt=not self.enhanced_hashing)
if validation:
ignore, userid, tokens, user_data, timestamp = validation
else:
return
tokens = tuple(tokens)
who_userid = identity['repoze.who.userid']
who_tokens = tuple(identity.get('tokens', ()))
who_userdata = identity.get('userdata', '')
who_userid = utf_8_encode(who_userid)[0]
old_data = (userid, tokens, userdata)
new_data = (who_userid, who_tokens, who_userdata)
def parseProduction(parser, lhs, str, tok=None, this=0):
"The parser itself."
if tok == "": return tok, this # EOF
lookupTable = parser.branchTable[lhs]
rhs = lookupTable.get(tok, None) # Predict branch from token
if rhs == None: raise SyntaxError(
"Found %s when expecting some form of %s,\n\tsuch as %s\n\t%s"
%(utf_8_encode(tok)[0], lhs, lookupTable.keys(), parser.around(str, this)))
print "%i %s means expand %s as %s" %(parser.lineNumber,tok, lhs, rhs.value())
for term in rhs:
if isinstance(term, Literal):
lit = term.value()
next = this + len(lit)
if str[this:next] == lit: pass
elif "@"+str[this:next-1] == lit: next = next-1
else: raise SyntaxError(
"Found %s where %s expected\n\t %s" %
(str[this:next], lit, parser.around(str, this)))
else:
rexp = tokenRegexps.get(term, None)
if rexp == None: # Not token
tok, this = parser.parseProduction(term, str, tok, this)
continue
m = rexp.match(str, this)
if m == None:
raise SyntaxError("Token: should match %s\n\t" %
(rexp.pattern, parser.around(str, this)))
# print u"Token matched to <%s> as pattern <%s>" % (str[this:m.end()], rexp.pattern)
next = m.end()
tok, this = parser.token(str, next) # Next token
return tok, this
def validate(s):
correct_utf16 = codecs.utf_16_encode(s)[0][2:]
utf8 = codecs.utf_8_encode(s)
p = subprocess.Popen("./utf16", stdin = subprocess.PIPE, stdout = subprocess.PIPE)
maybe_utf16 = p.communicate(utf8[0])[0]
if correct_utf16 != maybe_utf16:
print u"tried to do %r, got back %r, expected %r" % (utf8[0], maybe_utf16, correct_utf16)
raise "failed"
def eval_b(x):
"""Evaluate if to encode the value is necessary.
"""
if sys.version_info.major == 2:
return x
else:
import codecs
return codecs.utf_8_encode(x)[0]
def u2s(uni):
"""u2s - unicode to string, the safe way"""
if isinstance(uni, str):
return uni
else:
try:
return codecs.utf_8_encode(uni)[0]
except:
raise Exception("Ya talkin' gibberish? '{0}'".format(uni))
def get_nice_arg(arg, sig):
'''Convert an argument into a Java type when appropriate'''
env = get_env()
is_java = (isinstance(arg, javabridge.JB_Object) or
isinstance(arg, javabridge.JB_Class))
if sig[0] == 'L' and not is_java:
#
# Check for the standard packing of java objects into class instances
#
if hasattr(arg, "o"):
return arg.o
if (sig in ('Ljava/lang/String;','Ljava/lang/Object;') and not
isinstance(arg, javabridge.JB_Object)):
if isinstance(arg, unicode):
arg, _ = codecs.utf_8_encode(arg)
else:
arg = str(arg)
return env.new_string_utf(arg)
if sig == 'Ljava/lang/Integer;' and type(arg) in [int, long, bool]:
return make_instance('java/lang/Integer', '(I)V', int(arg))
if sig == 'Ljava/lang/Long' and type(arg) in [int, long, bool]:
return make_instance('java/lang/Long', '(J)V', long(arg))
if sig == 'Ljava/lang/Boolean;' and type(arg) in [int, long, bool]:
return make_instance('java/lang/Boolean', '(Z)V', bool(arg))
if isinstance(arg, np.ndarray):
if sig == '[Z':
return env.make_boolean_array(np.ascontiguousarray(arg.flatten(), np.bool8))
elif sig == '[B':
return env.make_byte_array(np.ascontiguousarray(arg.flatten(), np.uint8))
elif sig == '[S':
return env.make_short_array(np.ascontiguousarray(arg.flatten(), np.int16))
elif sig == '[I':
return env.make_int_array(np.ascontiguousarray(arg.flatten(), np.int32))
elif sig == '[J':
return env.make_long_array(np.ascontiguousarray(arg.flatten(), np.int64))
elif sig == '[F':
return env.make_float_array(np.ascontiguousarray(arg.flatten(), np.float32))
elif sig == '[D':
return env.make_double_array(np.ascontiguousarray(arg.flatten(), np.float64))
elif sig.startswith('L') and sig.endswith(';') and not is_java:
#
# Desperately try to make an instance of it with an integer constructor
#
if isinstance(arg, (int, long, bool)):
return make_instance(sig[1:-1], '(I)V', int(arg))
elif isinstance(arg, (str, unicode)):
return make_instance(sig[1:-1], '(Ljava/lang/String;)V', arg)
if sig.startswith('[L') and (not is_java) and hasattr(arg, '__iter__'):
objs = [get_nice_arg(subarg, sig[1:]) for subarg in arg]
k = env.find_class(sig[2:-1])
a = env.make_object_array(len(objs), k)
for i, obj in enumerate(objs):
env.set_object_array_element(a, i, obj)
return a
return arg
def __init__(self, filename):
self.csl_test = CslTest({}, None, (filename, ),
os.path.basename(filename))
self.csl_test.parse()
csl_io = io.BytesIO(utf_8_encode(self.data['csl'])[0])
self.style = CitationStylesStyle(csl_io)
self._fix_input(self.data['input'])
self.references = [item['id'] for item in self.data['input']]
self.references_dict = CiteProcJSON(self.data['input'])
self.bibliography = CitationStylesBibliography(self.style,
self.references_dict)
self.expected = self.data['result'].splitlines()
def check_password_hash(password_raw, password_hash, password_salt):
"""
Checks the given raw password against the hash and salt.
Assumes that the hash and salt are given in ASCII hex representation
and checks whether the password re-generates the hash when hashed
using the salt.
"""
return password_hash == hexlify(pbkdf2_hmac(
'sha256', utf_8_encode(password_raw)[0], unhexlify(password_salt),
_rounds))
def __init__(self, filename):
with open(filename, encoding='UTF-8') as f:
self.json_data = json.load(f)
csl_io = io.BytesIO(utf_8_encode(self.json_data['csl'])[0])
self.style = CitationStylesStyle(csl_io)
self._fix_input(self.json_data['input'])
self.references = [item['id'] for item in self.json_data['input']]
self.references_dict = CiteProcJSON(self.json_data['input'])
self.bibliography = CitationStylesBibliography(self.style,
self.references_dict)
self.expected = self.json_data['result'].splitlines()
def Credits(self,myfsm):
base.setBackgroundColor(0,0,0)
for i in self.items:
i.destroy()
font = loader.loadFont('fonts/PLUMP.TTF')
self.accept("i", myfsm.request, ["Intro"])
self.accept("escape", sys.exit)
self.tx = OnscreenText(text=(codecs.utf_8_encode("Credits")[0]), fg=(1,1,1,1), scale = 0.1, pos=(0,0.85),font=font, shadow= (0,0,0,1))
self.tx1= OnscreenText(text=(codecs.utf_8_encode("Gameplay Designer and Developer"+"\n"+"\n"+
"Andrea Tommaso Bonanno"+"\n"+"\n"+"\n"+
"Physics Implementation"+"\n"+"\n"+
"Alfredo Motta"+"\n"+"\n"+"\n"+
"Sound effects and developer"+"\n"+"\n"+
"Valerio Panzica La Manna"+"\n"+"\n"+"\n"+
"Art"+"\n"+"\n"+
"Ephraim Zev Zimmerman")[0]), fg=(1,1,1,1), scale = 0.07, pos=(0,0.64),font=font, shadow= (0,0,0,1))
self.tx2 = OnscreenText(text=(codecs.utf_8_encode("I: Intro - ESC: Exit")[0]), fg=(0.76,0.21,0,02), scale = 0.065, pos=(0,-0.9),font=font, shadow= (0,0,0,1))
self.items.append(self.tx)
self.items.append(self.tx1)
self.items.append(self.tx2)
def create_password_hash(password_raw):
"""
Create hash and salt for the given raw password.
The password is encoded as UTF-8 and a salt read from "os.random".
Returns ASCII hex representation of the hash and salt.
"""
password_salt = urandom(32)
password_hash = pbkdf2_hmac(
'sha256', utf_8_encode(password_raw)[0], password_salt, _rounds)
return (hexlify(password_hash), hexlify(password_salt))
def send(self, message):
message = utf_8_encode(unicode(message, 'latin-1'))[0]
msglen = len(message)
frameheader = 0x81
maskbit = 0
if msglen <= 125: masklen = chr(maskbit | msglen)
elif msglen < (1 << 16): masklen = chr(maskbit | 126) + struct.pack('!H', msglen)
elif msglen < (1 << 63): masklen = chr(maskbit | 127) + struct.pack('!Q', msglen)
framebytes = chr(frameheader) + masklen + message
with self._writelock:
self.socket.sendall(framebytes)
def create(uid,cn,sn):
l = ldapsetup()
if exists(uid):
return
uidNumber = random.randint(2000000,5000000)
while l.search_ext_s(ldapbase, filterstr='(uidNumber=%s)' % uidNumber, scope=ldap.SCOPE_SUBTREE):
uidNumber = random.randint(2000000,5000000)
l.add_s('uid=%s,ou=Clients,ou=Users,dc=bils,dc=se' % uid,
[('homeDirectory', ['/home/%s' % str(uid)]),
('sn', [codecs.utf_8_encode(sn)[0]]),
('cn', [codecs.utf_8_encode(cn)[0]]),
('uid',[str(uid)]),
('mail',[str(uid)]),
('loginShell', ['/bin/bash']),
('objectClass', ['posixAccount', 'shadowAccount', 'inetOrgPerson', 'person', 'top', 'organizationalPerson']),
('uidNumber', [str(uidNumber)]),
('gidNumber', [str(uidNumber)]),
])
def _buffer_encode_step(self, char, errors, final):
codepoint = ord(char)
if codepoint < 65535:
return codecs.utf_8_encode(char, errors)
else:
seq = bytearray(6)
seq[0] = 0xED
seq[1] = 0xA0 | (((codepoint & 0x1F0000) >> 16) - 1)
seq[2] = 0x80 | (codepoint & 0xFC00) >> 10
seq[3] = 0xED
seq[4] = 0xB0 | ((codepoint >> 6) & 0x3F)
seq[5] = 0x80 | (codepoint & 0x3F)
return bytes(seq), 1
def render(self, **kwargs):
output = getattr(self.source(), self.file_extension)
RESPONSE = self.request.RESPONSE
RESPONSE.setHeader(
"Content-disposition",
'filename="{}"'.format(codecs.utf_8_encode(self.filename)[0])
)
RESPONSE.setHeader(
"Content-Type", "{};charset=utf-8".format(self.content_type)
)
RESPONSE.setHeader("Content-Length", len(output))
return output
def get_response(self, filename, filehandle):
filename = codecs.utf_8_encode('filename="%s.pdf"' % filename)[0]
self.request.RESPONSE.setHeader('Content-disposition', filename)
self.request.RESPONSE.setHeader('Content-Type', 'application/pdf')
response = filehandle.getvalue()
filehandle.seek(0, os.SEEK_END)
filesize = filehandle.tell()
filehandle.close()
self.request.RESPONSE.setHeader('Content-Length', filesize)
return response
def handle_export(self):
try:
export_fields = self.parameters.get('export_fields')
export_fields = [
(id, title) for id, title
in self.portal_type_fields
if id in export_fields
]
review_state = self.parameters.get('review_state')
review_state = None if review_state == '__all__' else review_state
include_inactive = self.parameters.get('include_inactive')
dataset = export_people(
self.request,
self.context,
self.portal_type.id,
export_fields,
review_state,
include_inactive
)
variant = self.get_variant_by_name(self.parameters.get('variant'))
if variant:
dataset = variant.adjust_dataset(dataset, self.parameters)
if dataset is None:
raise ContentExportError(
_(u"The selected variant could not be applied")
)
format = self.parameters.get('export_format').lower()
filename = '%s.%s' % (self.context.title, format)
filename = codecs.utf_8_encode('filename="%s"' % filename)[0]
output = getattr(dataset, format)
RESPONSE = self.request.RESPONSE
RESPONSE.setHeader("Content-disposition", filename)
RESPONSE.setHeader(
"Content-Type", "application/%s;charset=utf-8" % format
)
RESPONSE.setHeader("Content-Length", len(output))
self.output = output
except ContentExportError as e:
self.raise_action_error(e.translate(self.request))
def render(self, **kwargs):
filename = '%s.%s' % (self.context.title, self.file_extension)
filename = codecs.utf_8_encode('filename="%s"' % filename)[0]
dataset = self.source()
output = getattr(dataset, self.file_extension)
RESPONSE = self.request.RESPONSE
RESPONSE.setHeader("Content-disposition", filename)
RESPONSE.setHeader(
"Content-Type", "%s;charset=utf-8" % self.content_type
)
RESPONSE.setHeader("Content-Length", len(output))
return output
def test_transport(self):
in_ = BytesIO(utf_8_encode('{"test_input":1}\n// END\n')[0])
out = BytesIO()
xp = TacoTransport(in_, out)
xp.write({'test_output': 2})
r = utf_8_decode(out.getvalue())[0]
self.assertEqual(r, "{\"test_output\": 2}\n// END\n")
r = xp.read()
self.assertEqual(r, {'test_input': 1})
def countsyll(instring):
"""This function counts the number of characters in a tamil string
This is done by ignoring the vowel additions. If one uses the len
function, the sample string has a length of 17 - but there are actually
only 11 characters"""
s = codecs.utf_8_encode(instring)
print s
x = codecs.utf_8_decode(s[0])[0]
print repr(x)
syllen = 0
vowels = [u'\u0bbe',u'\u0bbf',u'\u0bc0',
u'\u0bc1',u'\u0bc2',u'\u0bc6',
u'\u0bc7',u'\u0bc8',u'\u0bca',
u'\u0bcb',u'\u0bcc',u'\u0bcd',]
for y in x:
if y not in vowels:
syllen += 1
return syllen
def progress(*args):
level = len(traceback.extract_stack())
sys.stderr.write(" "*level)
for a in args:
i = 0
a = unicode(a)
while 1:
## lineCount[0] += 1
i = a.find("\n", i)
if i < 0: break
a = a[:i+1] + (" "*level) + a[i+1:]
i = i+1
q = utf_8_encode(u"%s " % (a,))[0]
sys.stderr.write(q)
## if lineCount[0] > 20:
## lineCount[0] = 0
## sys.stdin.readline()
sys.stderr.write("\n")
def progress(*args):
"""Logs a debug statement?
"""
level = len(traceback.extract_stack())
sys.stderr.write(" " * level)
for a in args:
i = 0
a = unicode(a)
# Indent all the levels of each of the args.
while 1:
## lineCount[0] += 1
i = a.find("\n", i)
if i < 0: break
a = a[:i+1] + (" " * level) + a[i+1:]
i = i + 1
q = utf_8_encode(u"%s " % (a,))[0]
sys.stderr.write(q)
## if lineCount[0] > 20:
## lineCount[0] = 0
## sys.stdin.readline()
sys.stderr.write("\n")
def on_lineEdit1_textChanged(self):
req = unicode(self.lineEdit1.text())
self.lineEditK.setText(roma(req))
if len(req) == 0:
return
latin1 = codecs.utf_8_encode(req)[0]
self.listWidget.clear()
v = os.popen("grep '" + latin1 + "' edict.utf8").readlines()
for entry in [codecs.utf_8_decode(line[:-1])[0] for line in v[:150]]:
if '['+req+']' in entry or entry.startswith(req + " "):
# exact match => move to top and color in gray
self.listWidget.insertItem(0, entry)
self.listWidget.item(0).setBackground(self.pen)
else:
self.listWidget.addItem(entry)
if len(req) == 1 and req in D_unichar:
infos_unicode = D_unichar[req]
entry = "\n".join(["%s: %s" % x for x in (sorted(infos_unicode, reverse=True))])[4:]
self.listWidget.insertItem(0, entry)
self.listWidget.item(0).setBackground(self.penUnicode)
self.listWidget.item(0).setFont(self.smallfont)
self.stackedWidget.setCurrentIndex(0)
if req.lower() == "samuel":
QtGui.QMessageBox.information(None, "Spoiled!", u"Dans cette série, il meurt à la fin", "TA GUEULE")
def encode(self, input, final=False): return codecs.utf_8_encode(input, self.errors)[0]
def latin1_to_utf8(text):
"helper to convert when needed from latin input"
return utf_8_encode(latin_1_decode(text)[0])[0]
def send(self,
url,
method="GET",
payload=None,
headers=None,
cookie=None,
auth=None,
content=''):
# initialize url service
urlib = self.framework.urlib(url)
if urlib.scheme == '':
url = urlib.sub_service("http")
# get random user agent
if self.rand_agent:
self.user_agent = self.framework.rand_uagent().get
# Makes a web request and returns a response object.
if method.upper() != "POST" and content:
raise RequestException(
"Invalid content type for the %s method: %s" %
(method, content))
# Prime local mutable variables to prevent persistence
if payload is None:
payload = {}
if headers is None:
headers = {}
if auth is None:
auth = ()
# Set request arguments
# Process user-agent header
headers["User-Agent"] = self.user_agent
if not headers["User-Agent"]:
headers["User-Agent"] = self.user_agent
# process payload
if content.upper() == "JSON":
headers["Content-Type"] = "application/json"
payload = json.dumps(payload)
else:
payload = urlencode(encode_payload(payload))
# process basic authentication
if len(auth) == 2:
authorization = b64encode(
utf_8_encode('%s:%s' % (auth[0], auth[1]))).replace('\n', '')
headers["Authorization"] = "Basic %s" % (authorization)
# Process socket timeout
if self.timeout:
socket.setdefaulttimeout(self.timeout)
# Set handlers
# Declare handlers list according to debug setting
handlers = [
request.HTTPHandler(debuglevel=1),
request.HTTPSHandler(debuglevel=1)
] if self.debug else []
# Process cookie handler
if cookie is not None and cookie != {}:
if isinstance(cookie, dict):
str_cookie = ""
for i in cookie:
str_cookie += "%s=%s; " % (i, cookie[i])
headers["Cookie"] = str_cookie
else:
handlers.append(request.HTTPCookieProcessor(cookie))
# Process redirect and add handler
if not self.redirect:
handlers.append(NoRedirectHandler)
# Process proxies and add handler
if self.proxy:
proxies = {"http": self.proxy, "https": self.proxy}
handlers.append(request.ProxyHandler(proxies))
# Install opener
opener = request.build_opener(*handlers)
request.install_opener(opener)
# Process method and make request
if method == "GET":
if payload:
url = "%s?%s" % (url, payload)
req = request.Request(url, headers=headers)
elif method == "POST":
req = request.Request(url, data=payload, headers=headers)
elif method == "HEAD":
if payload:
url = "%s?%s" % (url, payload)
req = request.Request(url, headers=headers)
req.get_method = lambda: "HEAD"
else:
raise RequestException(
"Request method \'%s\' is not a supported method." % (method))
try:
resp = request.urlopen(req)
except request.HTTPError as e:
resp = e
# Build and return response object
return ResponseObject(resp, cookie)
def _s2b(string):
"""Python 3: convert the string to binary data"""
return codecs.utf_8_encode(string)[0]
def encode(input, errors='strict'):
return (codecs.BOM_UTF8 +
codecs.utf_8_encode(input, errors)[0], len(input))
# LOCALIZATION NOTE (getting_started): # link title for http://www.mozilla.com/en-US/firefox/central/ #define getting_started %s # LOCALIZATION NOTE (firefox_heading): # Firefox links folder name #define firefox_heading %s # LOCALIZATION NOTE (firefox_help): # link title for http://www.mozilla.com/en-US/firefox/help/ #define firefox_help %s # LOCALIZATION NOTE (firefox_customize): # link title for http://www.mozilla.com/en-US/firefox/customize/ #define firefox_customize %s # LOCALIZATION NOTE (firefox_community): # link title for http://www.mozilla.com/en-US/firefox/community/ #define firefox_community %s # LOCALIZATION NOTE (firefox_about): # link title for http://www.mozilla.com/en-US/about/ #define firefox_about %s #unfilter emptyLines''' strings = tuple(e.val for e in p if ll.search(e.key)) print codecs.utf_8_encode(template % strings)[0]
def encode(input, errors='strict'):
return (codecs.BOM_UTF8 + codecs.utf_8_encode(input, errors)[0], len(input))
def encode_utf8(x):
return codecs.utf_8_encode(x)[0]
def encode(self, input, final=False):
return codecs.utf_8_encode(input, self.errors)[0]
def utf8ise(s): return codecs.utf_8_encode(s)[0]
