Searched refs:unicodedata (Results 1 - 22 of 22) sorted by relevance

/prebuilts/python/darwin-x86/2.7.5/lib/python2.7/test/
H A Dtest_ucn.py64 import unicodedata namespace
68 code = unicodedata.lookup(name)
69 self.assertEqual(unicodedata.name(code), name)
86 import unicodedata namespace
87 self.assertRaises(ValueError, unicodedata.name, u"\ud7a4")
98 import unicodedata namespace
102 name = unicodedata.name(char, None)
104 self.assertEqual(unicodedata.lookup(name), char)
114 import unicodedata namespace
115 self.assertRaises(TypeError, unicodedata
[all...]
H A Dtest_unicode_file.py5 import unicodedata namespace
71 base = unicodedata.normalize("NFD", base)
72 file_list = [unicodedata.normalize("NFD", f) for f in file_list]
131 cwd_result = unicodedata.normalize("NFD", cwd_result)
132 name_result = unicodedata.normalize("NFD", name_result)
H A Dtest_unicodedata.py1 """ Test script for the unicodedata module.
71 # In case unicodedata is not available, this will raise an ImportError,
73 import unicodedata namespace
74 self.db = unicodedata
224 # Decoding \N escapes requires the unicodedata module. If it can't be
229 "sys.modules['unicodedata'] = None;" \
232 # We use a subprocess because the unicodedata module may already have
238 "(can't load unicodedata module)"
271 import unicodedata namespace
273 self.assertTrue(unicodedata
[all...]
H A Dtest_normalization.py7 from unicodedata import normalize, unidata_version
H A Dtest_inspect.py20 import unicodedata namespace
391 not hasattr(unicodedata, '__file__') or
392 unicodedata.__file__[-4:] in (".pyc", ".pyo"),
393 "unicodedata is not an external binary module")
395 self.assertRaises(IOError, inspect.getsource, unicodedata)
396 self.assertRaises(IOError, inspect.findsource, unicodedata)
H A Dtest_pep277.py4 from unicodedata import normalize
H A Dtest_codeccallbacks.py2 import sys, codecs, htmlentitydefs, unicodedata namespace
119 l.append(unicodedata.name(c, u"0x%x" % ord(c)))
/prebuilts/python/linux-x86/2.7.5/lib/python2.7/test/
H A Dtest_ucn.py64 import unicodedata namespace
68 code = unicodedata.lookup(name)
69 self.assertEqual(unicodedata.name(code), name)
86 import unicodedata namespace
87 self.assertRaises(ValueError, unicodedata.name, u"\ud7a4")
98 import unicodedata namespace
102 name = unicodedata.name(char, None)
104 self.assertEqual(unicodedata.lookup(name), char)
114 import unicodedata namespace
115 self.assertRaises(TypeError, unicodedata
[all...]
H A Dtest_unicode_file.py5 import unicodedata namespace
71 base = unicodedata.normalize("NFD", base)
72 file_list = [unicodedata.normalize("NFD", f) for f in file_list]
131 cwd_result = unicodedata.normalize("NFD", cwd_result)
132 name_result = unicodedata.normalize("NFD", name_result)
H A Dtest_unicodedata.py1 """ Test script for the unicodedata module.
71 # In case unicodedata is not available, this will raise an ImportError,
73 import unicodedata namespace
74 self.db = unicodedata
224 # Decoding \N escapes requires the unicodedata module. If it can't be
229 "sys.modules['unicodedata'] = None;" \
232 # We use a subprocess because the unicodedata module may already have
238 "(can't load unicodedata module)"
271 import unicodedata namespace
273 self.assertTrue(unicodedata
[all...]
H A Dtest_normalization.py7 from unicodedata import normalize, unidata_version
H A Dtest_inspect.py20 import unicodedata namespace
391 not hasattr(unicodedata, '__file__') or
392 unicodedata.__file__[-4:] in (".pyc", ".pyo"),
393 "unicodedata is not an external binary module")
395 self.assertRaises(IOError, inspect.getsource, unicodedata)
396 self.assertRaises(IOError, inspect.findsource, unicodedata)
H A Dtest_pep277.py4 from unicodedata import normalize
H A Dtest_codeccallbacks.py2 import sys, codecs, htmlentitydefs, unicodedata namespace
119 l.append(unicodedata.name(c, u"0x%x" % ord(c)))
/prebuilts/python/darwin-x86/2.7.5/lib/python2.7/
H A Dstringprep.py8 from unicodedata import ucd_3_2_0 as unicodedata namespace
10 assert unicodedata.unidata_version == '3.2.0'
13 if unicodedata.category(code) != 'Cn': return False
197 b = unicodedata.normalize("NFKC", al)
199 c = unicodedata.normalize("NFKC", bl)
211 return unicodedata.category(code) == "Zs" and code != u" "
214 return unicodedata.category(code) == "Zs"
218 return ord(code) < 128 and unicodedata.category(code) == "Cc"
224 if unicodedata
[all...]
/prebuilts/python/linux-x86/2.7.5/lib/python2.7/
H A Dstringprep.py8 from unicodedata import ucd_3_2_0 as unicodedata namespace
10 assert unicodedata.unidata_version == '3.2.0'
13 if unicodedata.category(code) != 'Cn': return False
197 b = unicodedata.normalize("NFKC", al)
199 c = unicodedata.normalize("NFKC", bl)
211 return unicodedata.category(code) == "Zs" and code != u" "
214 return unicodedata.category(code) == "Zs"
218 return ord(code) < 128 and unicodedata.category(code) == "Cc"
224 if unicodedata
[all...]
/prebuilts/python/darwin-x86/2.7.5/lib/python2.7/encodings/
H A Didna.py4 from unicodedata import ucd_3_2_0 as unicodedata namespace
25 label = unicodedata.normalize("NFKC", label)
/prebuilts/python/linux-x86/2.7.5/lib/python2.7/encodings/
H A Didna.py4 from unicodedata import ucd_3_2_0 as unicodedata namespace
25 label = unicodedata.normalize("NFKC", label)
/prebuilts/python/darwin-x86/2.7.5/lib/python2.7/pydoc_data/
H A Dtopics.py52 'operator-summary': '\nOperator precedence\n*******************\n\nThe following table summarizes the operator precedences in Python,\nfrom lowest precedence (least binding) to highest precedence (most\nbinding). Operators in the same box have the same precedence. Unless\nthe syntax is explicitly given, operators are binary. Operators in\nthe same box group left to right (except for comparisons, including\ntests, which all have the same precedence and chain from left to right\n--- see section *Comparisons* --- and exponentiation, which groups\nfrom right to left).\n\n+-------------------------------------------------+---------------------------------------+\n| Operator | Description |\n+=================================================+=======================================+\n| ``lambda`` | Lambda expression |\n+-------------------------------------------------+---------------------------------------+\n| ``if`` -- ``else`` | Conditional expression |\n+-------------------------------------------------+---------------------------------------+\n| ``or`` | Boolean OR |\n+-------------------------------------------------+---------------------------------------+\n| ``and`` | Boolean AND |\n+-------------------------------------------------+---------------------------------------+\n| ``not`` ``x`` | Boolean NOT |\n+-------------------------------------------------+---------------------------------------+\n| ``in``, ``not in``, ``is``, ``is not``, ``<``, | Comparisons, including membership |\n| ``<=``, ``>``, ``>=``, ``<>``, ``!=``, ``==`` | tests and identity tests |\n+-------------------------------------------------+---------------------------------------+\n| ``|`` | Bitwise OR |\n+-------------------------------------------------+---------------------------------------+\n| ``^`` | Bitwise XOR |\n+-------------------------------------------------+---------------------------------------+\n| ``&`` | Bitwise AND |\n+-------------------------------------------------+---------------------------------------+\n| ``<<``, ``>>`` | Shifts |\n+-------------------------------------------------+---------------------------------------+\n| ``+``, ``-`` | Addition and subtraction |\n+-------------------------------------------------+---------------------------------------+\n| ``*``, ``/``, ``//``, ``%`` | Multiplication, division, remainder |\n| | [8] |\n+-------------------------------------------------+---------------------------------------+\n| ``+x``, ``-x``, ``~x`` | Positive, negative, bitwise NOT |\n+-------------------------------------------------+---------------------------------------+\n| ``**`` | Exponentiation [9] |\n+-------------------------------------------------+---------------------------------------+\n| ``x[index]``, ``x[index:index]``, | Subscription, slicing, call, |\n| ``x(arguments...)``, ``x.attribute`` | attribute reference |\n+-------------------------------------------------+---------------------------------------+\n| ``(expressions...)``, ``[expressions...]``, | Binding or tuple display, list |\n| ``{key: value...}``, ```expressions...``` | display, dictionary display, string |\n| | conversion |\n+-------------------------------------------------+---------------------------------------+\n\n-[ Footnotes ]-\n\n[1] In Python 2.3 and later releases, a list comprehension "leaks" the\n control variables of each ``for`` it contains into the containing\n scope. However, this behavior is deprecated, and relying on it\n will not work in Python 3.\n\n[2] While ``abs(x%y) < abs(y)`` is true mathematically, for floats it\n may not be true numerically due to roundoff. For example, and\n assuming a platform on which a Python float is an IEEE 754 double-\n precision number, in order that ``-1e-100 % 1e100`` have the same\n sign as ``1e100``, the computed result is ``-1e-100 + 1e100``,\n which is numerically exactly equal to ``1e100``. The function\n ``math.fmod()`` returns a result whose sign matches the sign of\n the first argument instead, and so returns ``-1e-100`` in this\n case. Which approach is more appropriate depends on the\n application.\n\n[3] If x is very close to an exact integer multiple of y, it\'s\n possible for ``floor(x/y)`` to be one larger than ``(x-x%y)/y``\n due to rounding. In such cases, Python returns the latter result,\n in order to preserve that ``divmod(x,y)[0] * y + x % y`` be very\n close to ``x``.\n\n[4] While comparisons between unicode strings make sense at the byte\n level, they may be counter-intuitive to users. For example, the\n strings ``u"\\u00C7"`` and ``u"\\u0043\\u0327"`` compare differently,\n even though they both represent the same unicode character (LATIN\n CAPITAL LETTER C WITH CEDILLA). To compare strings in a human\n recognizable way, compare using ``unicodedata.normalize()``.\n\n[5] The implementation computes this efficiently, without constructing\n lists or sorting.\n\n[6] Earlier versions of Python used lexicographic comparison of the\n sorted (key, value) lists, but this was very expensive for the\n common case of comparing for equality. An even earlier version of\n Python compared dictionaries by identity only, but this caused\n surprises because people expected to be able to test a dictionary\n for emptiness by comparing it to ``{}``.\n\n[7] Due to automatic garbage-collection, free lists, and the dynamic\n nature of descriptors, you may notice seemingly unusual behaviour\n in certain uses of the ``is`` operator, like those involving\n comparisons between instance methods, or constants. Check their\n documentation for more info.\n\n[8] The ``%`` operator is also used for string formatting; the same\n precedence applies.\n\n[9] The power operator ``**`` binds less tightly than an arithmetic or\n bitwise unary operator on its right, that is, ``2**-1`` is\n ``0.5``.\n',
/prebuilts/python/linux-x86/2.7.5/lib/python2.7/pydoc_data/
H A Dtopics.py52 'operator-summary': '\nOperator precedence\n*******************\n\nThe following table summarizes the operator precedences in Python,\nfrom lowest precedence (least binding) to highest precedence (most\nbinding). Operators in the same box have the same precedence. Unless\nthe syntax is explicitly given, operators are binary. Operators in\nthe same box group left to right (except for comparisons, including\ntests, which all have the same precedence and chain from left to right\n--- see section *Comparisons* --- and exponentiation, which groups\nfrom right to left).\n\n+-------------------------------------------------+---------------------------------------+\n| Operator | Description |\n+=================================================+=======================================+\n| ``lambda`` | Lambda expression |\n+-------------------------------------------------+---------------------------------------+\n| ``if`` -- ``else`` | Conditional expression |\n+-------------------------------------------------+---------------------------------------+\n| ``or`` | Boolean OR |\n+-------------------------------------------------+---------------------------------------+\n| ``and`` | Boolean AND |\n+-------------------------------------------------+---------------------------------------+\n| ``not`` ``x`` | Boolean NOT |\n+-------------------------------------------------+---------------------------------------+\n| ``in``, ``not in``, ``is``, ``is not``, ``<``, | Comparisons, including membership |\n| ``<=``, ``>``, ``>=``, ``<>``, ``!=``, ``==`` | tests and identity tests |\n+-------------------------------------------------+---------------------------------------+\n| ``|`` | Bitwise OR |\n+-------------------------------------------------+---------------------------------------+\n| ``^`` | Bitwise XOR |\n+-------------------------------------------------+---------------------------------------+\n| ``&`` | Bitwise AND |\n+-------------------------------------------------+---------------------------------------+\n| ``<<``, ``>>`` | Shifts |\n+-------------------------------------------------+---------------------------------------+\n| ``+``, ``-`` | Addition and subtraction |\n+-------------------------------------------------+---------------------------------------+\n| ``*``, ``/``, ``//``, ``%`` | Multiplication, division, remainder |\n| | [8] |\n+-------------------------------------------------+---------------------------------------+\n| ``+x``, ``-x``, ``~x`` | Positive, negative, bitwise NOT |\n+-------------------------------------------------+---------------------------------------+\n| ``**`` | Exponentiation [9] |\n+-------------------------------------------------+---------------------------------------+\n| ``x[index]``, ``x[index:index]``, | Subscription, slicing, call, |\n| ``x(arguments...)``, ``x.attribute`` | attribute reference |\n+-------------------------------------------------+---------------------------------------+\n| ``(expressions...)``, ``[expressions...]``, | Binding or tuple display, list |\n| ``{key: value...}``, ```expressions...``` | display, dictionary display, string |\n| | conversion |\n+-------------------------------------------------+---------------------------------------+\n\n-[ Footnotes ]-\n\n[1] In Python 2.3 and later releases, a list comprehension "leaks" the\n control variables of each ``for`` it contains into the containing\n scope. However, this behavior is deprecated, and relying on it\n will not work in Python 3.\n\n[2] While ``abs(x%y) < abs(y)`` is true mathematically, for floats it\n may not be true numerically due to roundoff. For example, and\n assuming a platform on which a Python float is an IEEE 754 double-\n precision number, in order that ``-1e-100 % 1e100`` have the same\n sign as ``1e100``, the computed result is ``-1e-100 + 1e100``,\n which is numerically exactly equal to ``1e100``. The function\n ``math.fmod()`` returns a result whose sign matches the sign of\n the first argument instead, and so returns ``-1e-100`` in this\n case. Which approach is more appropriate depends on the\n application.\n\n[3] If x is very close to an exact integer multiple of y, it\'s\n possible for ``floor(x/y)`` to be one larger than ``(x-x%y)/y``\n due to rounding. In such cases, Python returns the latter result,\n in order to preserve that ``divmod(x,y)[0] * y + x % y`` be very\n close to ``x``.\n\n[4] While comparisons between unicode strings make sense at the byte\n level, they may be counter-intuitive to users. For example, the\n strings ``u"\\u00C7"`` and ``u"\\u0043\\u0327"`` compare differently,\n even though they both represent the same unicode character (LATIN\n CAPITAL LETTER C WITH CEDILLA). To compare strings in a human\n recognizable way, compare using ``unicodedata.normalize()``.\n\n[5] The implementation computes this efficiently, without constructing\n lists or sorting.\n\n[6] Earlier versions of Python used lexicographic comparison of the\n sorted (key, value) lists, but this was very expensive for the\n common case of comparing for equality. An even earlier version of\n Python compared dictionaries by identity only, but this caused\n surprises because people expected to be able to test a dictionary\n for emptiness by comparing it to ``{}``.\n\n[7] Due to automatic garbage-collection, free lists, and the dynamic\n nature of descriptors, you may notice seemingly unusual behaviour\n in certain uses of the ``is`` operator, like those involving\n comparisons between instance methods, or constants. Check their\n documentation for more info.\n\n[8] The ``%`` operator is also used for string formatting; the same\n precedence applies.\n\n[9] The power operator ``**`` binds less tightly than an arithmetic or\n bitwise unary operator on its right, that is, ``2**-1`` is\n ``0.5``.\n',
/prebuilts/devtools/tools/lib/
H A Djython-standalone-2.5.3.jarMETA-INF/MANIFEST.MF META-INF/LICENSE META-INF/NOTICE META-INF/maven/jline/ ...
/prebuilts/tools/common/m2/repository/org/python/jython-standalone/2.5.3/
H A Djython-standalone-2.5.3.jarMETA-INF/MANIFEST.MF META-INF/LICENSE META-INF/NOTICE META-INF/maven/jline/ ...

Completed in 236 milliseconds