Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package python-PyICU for openSUSE:Factory
checked in at 2024-11-08 11:55:50
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-PyICU (Old)
and /work/SRC/openSUSE:Factory/.python-PyICU.new.2017 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-PyICU"
Fri Nov 8 11:55:50 2024 rev:20 rq:1222456 version:2.14
Changes:
--------
--- /work/SRC/openSUSE:Factory/python-PyICU/python-PyICU.changes
2024-06-17 19:27:25.757721712 +0200
+++ /work/SRC/openSUSE:Factory/.python-PyICU.new.2017/python-PyICU.changes
2024-11-08 11:58:18.770792250 +0100
@@ -1,0 +2,11 @@
+Thu Nov 7 10:04:14 UTC 2024 - John Paul Adrian Glaubitz
<adrian.glaub...@suse.com>
+
+- Update to 2.14
+ * added wrappers for UCPMap.get|getRange and Char.getIntPropertyMap
+ * added wrapper for Locale.getUnicodeKeywordValue
+ * added wrapper for UnicodeString.remove, UnicodeString.removeBetween
+ * added wrapper for UnicodeString.retainBetween, UnicodeString.truncate
+ * fixed bogus UBool uses on stack instead of int (Martin Jansche)
+ * added support for ICU 76.1
+
+-------------------------------------------------------------------
Old:
----
PyICU-2.13.1.tar.gz
New:
----
PyICU-2.14.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-PyICU.spec ++++++
--- /var/tmp/diff_new_pack.dfJmXH/_old 2024-11-08 11:58:19.334815771 +0100
+++ /var/tmp/diff_new_pack.dfJmXH/_new 2024-11-08 11:58:19.334815771 +0100
@@ -19,7 +19,7 @@
%{?sle15_python_module_pythons}
%global modname PyICU
Name: python-%{modname}
-Version: 2.13.1
+Version: 2.14
Release: 0
Summary: Python Extension Wrapping the ICU C++ API
License: MIT
++++++ PyICU-2.13.1.tar.gz -> PyICU-2.14.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyicu-2.13.1/CHANGES new/pyicu-2.14/CHANGES
--- old/pyicu-2.13.1/CHANGES 2024-04-29 22:10:23.000000000 +0200
+++ new/pyicu-2.14/CHANGES 2024-10-26 10:19:21.000000000 +0200
@@ -1,3 +1,12 @@
+Version 2.13.1 -> 2.14
+----------------------
+ - added wrappers for UCPMap.get|getRange and Char.getIntPropertyMap
+ - added wrapper for Locale.getUnicodeKeywordValue
+ - added wrapper for UnicodeString.remove, UnicodeString.removeBetween
+ - added wrapper for UnicodeString.retainBetween, UnicodeString.truncate
+ - fixed bogus UBool uses on stack instead of int (Martin Jansche)
+ - added support for ICU 76.1
+
Version 2.13 -> 2.13.1
----------------------
- change c++11 to c++17 in setup.py as current versions of ICU require it
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyicu-2.13.1/PKG-INFO new/pyicu-2.14/PKG-INFO
--- old/pyicu-2.13.1/PKG-INFO 2024-04-29 22:17:30.886317000 +0200
+++ new/pyicu-2.14/PKG-INFO 2024-10-26 10:44:06.422617700 +0200
@@ -1,6 +1,6 @@
Metadata-Version: 2.1
Name: PyICU
-Version: 2.13.1
+Version: 2.14
Summary: Python extension wrapping the ICU C++ API
Home-page: https://gitlab.pyicu.org/main/pyicu
Author: Andi Vajda
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyicu-2.13.1/bases.cpp new/pyicu-2.14/bases.cpp
--- old/pyicu-2.13.1/bases.cpp 2023-12-22 13:49:23.000000000 +0100
+++ new/pyicu-2.14/bases.cpp 2024-10-26 10:35:46.000000000 +0200
@@ -391,7 +391,11 @@
static PyObject *t_unicodestring_lastIndexOf(t_unicodestring *self,
PyObject *args);
static PyObject *t_unicodestring_trim(t_unicodestring *self);
-static PyObject *t_unicodestring_reverse(t_unicodestring *self);
+static PyObject *t_unicodestring_truncate(t_unicodestring *self, PyObject
*arg);
+static PyObject *t_unicodestring_reverse(t_unicodestring *self, PyObject
*args);
+static PyObject *t_unicodestring_remove(t_unicodestring *self, PyObject *args);
+static PyObject *t_unicodestring_removeBetween(t_unicodestring *self, PyObject
*args);
+static PyObject *t_unicodestring_retainBetween(t_unicodestring *self, PyObject
*args);
static PyObject *t_unicodestring_toUpper(t_unicodestring *self, PyObject
*args);
static PyObject *t_unicodestring_toLower(t_unicodestring *self, PyObject
*args);
static PyObject *t_unicodestring_toTitle(t_unicodestring *self, PyObject
*args);
@@ -434,7 +438,11 @@
DECLARE_METHOD(t_unicodestring, indexOf, METH_VARARGS),
DECLARE_METHOD(t_unicodestring, lastIndexOf, METH_VARARGS),
DECLARE_METHOD(t_unicodestring, trim, METH_NOARGS),
- DECLARE_METHOD(t_unicodestring, reverse, METH_NOARGS),
+ DECLARE_METHOD(t_unicodestring, truncate, METH_O),
+ DECLARE_METHOD(t_unicodestring, reverse, METH_VARARGS),
+ DECLARE_METHOD(t_unicodestring, remove, METH_VARARGS),
+ DECLARE_METHOD(t_unicodestring, removeBetween, METH_VARARGS),
+ DECLARE_METHOD(t_unicodestring, retainBetween, METH_VARARGS),
DECLARE_METHOD(t_unicodestring, toUpper, METH_VARARGS),
DECLARE_METHOD(t_unicodestring, toLower, METH_VARARGS),
DECLARE_METHOD(t_unicodestring, toTitle, METH_VARARGS),
@@ -1042,7 +1050,11 @@
}
if (!parseArgs(args, "i", &i))
{
+#if PY_VERSION_HEX < 0x030d0000
if (sizeof(Py_UNICODE) == sizeof(UChar))
+#else
+ if (sizeof(wchar_t) == sizeof(UChar))
+#endif
self->object->append((UChar) i);
else
self->object->append((UChar32) i);
@@ -1314,7 +1326,11 @@
{
int i;
+#if PY_VERSION_HEX < 0x030d0000
if (sizeof(Py_UNICODE) == sizeof(UChar))
+#else
+ if (sizeof(wchar_t) == sizeof(UChar))
+#endif
i = self->object->indexOf((UChar) c);
else
i = self->object->indexOf((UChar32) c);
@@ -1339,7 +1355,11 @@
{
int i;
+#if PY_VERSION_HEX < 0x030d0000
if (sizeof(Py_UNICODE) == sizeof(UChar))
+#else
+ if (sizeof(wchar_t) == sizeof(UChar))
+#endif
i = self->object->indexOf((UChar) c, start);
else
i = self->object->indexOf((UChar32) c, start);
@@ -1367,7 +1387,11 @@
{
int i;
+#if PY_VERSION_HEX < 0x030d0000
if (sizeof(Py_UNICODE) == sizeof(UChar))
+#else
+ if (sizeof(wchar_t) == sizeof(UChar))
+#endif
i = self->object->indexOf((UChar) c, start, len);
else
i = self->object->indexOf((UChar32) c, start, len);
@@ -1413,7 +1437,11 @@
{
int i;
+#if PY_VERSION_HEX < 0x030d0000
if (sizeof(Py_UNICODE) == sizeof(UChar))
+#else
+ if (sizeof(wchar_t) == sizeof(UChar))
+#endif
i = self->object->lastIndexOf((UChar) c);
else
i = self->object->lastIndexOf((UChar32) c);
@@ -1438,7 +1466,11 @@
{
int i;
+#if PY_VERSION_HEX < 0x030d0000
if (sizeof(Py_UNICODE) == sizeof(UChar))
+#else
+ if (sizeof(wchar_t) == sizeof(UChar))
+#endif
i = self->object->lastIndexOf((UChar) c, start);
else
i = self->object->lastIndexOf((UChar32) c, start);
@@ -1466,7 +1498,11 @@
{
int i;
+#if PY_VERSION_HEX < 0x030d0000
if (sizeof(Py_UNICODE) == sizeof(UChar))
+#else
+ if (sizeof(wchar_t) == sizeof(UChar))
+#endif
i = self->object->lastIndexOf((UChar) c, start, len);
else
i = self->object->lastIndexOf((UChar32) c, start, len);
@@ -1502,10 +1538,117 @@
Py_RETURN_SELF();
}
-static PyObject *t_unicodestring_reverse(t_unicodestring *self)
+static PyObject *t_unicodestring_truncate(t_unicodestring *self, PyObject *arg)
{
- self->object->reverse();
- Py_RETURN_SELF();
+ int length;
+
+ if (!parseArg(arg, "i", &length))
+ {
+ self->object->truncate(length);
+ Py_RETURN_SELF();
+ }
+
+ return PyErr_SetArgsError((PyObject *) self, "truncate", arg);
+}
+
+static PyObject *t_unicodestring_reverse(t_unicodestring *self, PyObject *args)
+{
+ int start, length;
+
+ switch (PyTuple_Size(args)) {
+ case 0:
+ self->object->reverse();
+ Py_RETURN_SELF();
+ case 2:
+ if (!parseArgs(args, "ii", &start, &length))
+ {
+ self->object->reverse(start, length);
+ Py_RETURN_SELF();
+ }
+ break;
+ }
+
+ return PyErr_SetArgsError((PyObject *) self, "reverse", args);
+}
+
+static PyObject *t_unicodestring_remove(t_unicodestring *self, PyObject *args)
+{
+ int start, length;
+
+ switch (PyTuple_Size(args)) {
+ case 0:
+ self->object->remove();
+ Py_RETURN_SELF();
+ case 1:
+ if (!parseArgs(args, "i", &start))
+ {
+ self->object->remove(start);
+ Py_RETURN_SELF();
+ }
+ break;
+ case 2:
+ if (!parseArgs(args, "ii", &start, &length))
+ {
+ self->object->remove(start, length);
+ Py_RETURN_SELF();
+ }
+ break;
+ }
+
+ return PyErr_SetArgsError((PyObject *) self, "remove", args);
+}
+
+static PyObject *t_unicodestring_removeBetween(t_unicodestring *self, PyObject
*args)
+{
+ int start, limit;
+
+ switch (PyTuple_Size(args)) {
+ case 0:
+ self->object->remove();
+ Py_RETURN_SELF();
+ case 1:
+ if (!parseArgs(args, "i", &start))
+ {
+ self->object->removeBetween(start);
+ Py_RETURN_SELF();
+ }
+ break;
+ case 2:
+ if (!parseArgs(args, "ii", &start, &limit))
+ {
+ self->object->removeBetween(start, limit);
+ Py_RETURN_SELF();
+ }
+ break;
+ }
+
+ return PyErr_SetArgsError((PyObject *) self, "removeBetween", args);
+}
+
+static PyObject *t_unicodestring_retainBetween(t_unicodestring *self, PyObject
*args)
+{
+ int start, limit;
+
+ switch (PyTuple_Size(args)) {
+ case 0:
+ Py_RETURN_SELF();
+ case 1:
+ if (!parseArgs(args, "i", &start))
+ {
+ self->object->retainBetween(start);
+ Py_RETURN_SELF();
+ }
+ break;
+ case 2:
+ if (!parseArgs(args, "ii", &start, &limit))
+ {
+ self->object->retainBetween(start, limit);
+ Py_RETURN_SELF();
+ }
+ break;
+ }
+
+ return PyErr_SetArgsError((PyObject *) self, "retainBetween", args);
}
static PyObject *t_unicodestring_toUpper(t_unicodestring *self, PyObject *args)
@@ -1706,8 +1849,8 @@
static PyObject *t_unicodestring_countChar32(t_unicodestring *self,
PyObject *args)
{
- int32_t start = 0, length = INT32_MAX;
- int32_t len;
+ int start = 0, length = INT32_MAX;
+ int len;
switch (PyTuple_Size(args)) {
case 0:
@@ -2068,7 +2211,7 @@
if (n >= 0 && n < len)
{
- int32_t i;
+ int i;
if (!parseArg(arg, "i", &i))
{
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyicu-2.13.1/char.cpp new/pyicu-2.14/char.cpp
--- old/pyicu-2.13.1/char.cpp 2024-04-13 21:52:32.000000000 +0200
+++ new/pyicu-2.14/char.cpp 2024-10-02 03:37:25.000000000 +0200
@@ -50,6 +50,7 @@
DECLARE_CONSTANTS_TYPE(UIndicPositionalCategory)
DECLARE_CONSTANTS_TYPE(UIndicSyllabicCategory)
DECLARE_CONSTANTS_TYPE(UVerticalOrientation)
+DECLARE_CONSTANTS_TYPE(UCPMapRangeOption)
#endif
#if U_ICU_VERSION_HEX >= VERSION_HEX(75, 0, 0)
DECLARE_CONSTANTS_TYPE(UIdentifierType)
@@ -70,6 +71,7 @@
static PyObject *t_char_hasBinaryProperty(PyTypeObject *type, PyObject *args);
#if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0)
static PyObject *t_char_getBinaryPropertySet(PyTypeObject *type, PyObject
*arg);
+static PyObject *t_char_getIntPropertyMap(PyTypeObject *type, PyObject *arg);
#endif
static PyObject *t_char_getIntPropertyValue(PyTypeObject *type, PyObject
*args);
static PyObject *t_char_getIntPropertyMinValue(PyTypeObject *type,
@@ -142,6 +144,7 @@
DECLARE_METHOD(t_char, hasBinaryProperty, METH_VARARGS | METH_CLASS),
#if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0)
DECLARE_METHOD(t_char, getBinaryPropertySet, METH_O | METH_CLASS),
+ DECLARE_METHOD(t_char, getIntPropertyMap, METH_O | METH_CLASS),
#endif
DECLARE_METHOD(t_char, getIntPropertyValue, METH_VARARGS | METH_CLASS),
DECLARE_METHOD(t_char, getIntPropertyMinValue, METH_O | METH_CLASS),
@@ -215,6 +218,33 @@
DECLARE_STRUCT(Char, t_char, UNone, t_char_init, t_char_dealloc)
+/* UCPMap */
+
+#if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0)
+
+class t_ucpmap : public _wrapper {
+public:
+ UCPMap *object;
+};
+
+static PyObject *t_ucpmap_get(t_ucpmap *self, PyObject *arg);
+static PyObject *t_ucpmap_getRange(t_ucpmap *self, PyObject *args);
+
+static PyMethodDef t_ucpmap_methods[] = {
+ DECLARE_METHOD(t_ucpmap, get, METH_O),
+ DECLARE_METHOD(t_ucpmap, getRange, METH_VARARGS),
+ { NULL, NULL, 0, NULL }
+};
+
+static void t_ucpmap_dealloc(t_char *self)
+{
+ Py_TYPE(self)->tp_free((PyObject *) self);
+}
+
+DECLARE_STRUCT(UCPMap, t_ucpmap, UCPMap, abstract_init, t_ucpmap_dealloc)
+
+#endif // ICU >= 63
+
/* Char */
static int t_char_init(t_char *self, PyObject *args, PyObject *kwds)
@@ -249,6 +279,7 @@
}
#if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0)
+
static PyObject *t_char_getBinaryPropertySet(PyTypeObject *type, PyObject *arg)
{
UProperty prop;
@@ -264,7 +295,23 @@
return PyErr_SetArgsError((PyObject *) type, "getBinaryPropertySet", arg);
}
-#endif
+
+static PyObject *t_char_getIntPropertyMap(PyTypeObject *type, PyObject *arg)
+{
+ UProperty prop;
+
+ if (!parseArg(arg, "i", &prop))
+ {
+ const UCPMap *map;
+ STATUS_CALL(map = u_getIntPropertyMap(prop, &status));
+
+ return wrap_UCPMap(const_cast<UCPMap *>(map), 0);
+ }
+
+ return PyErr_SetArgsError((PyObject *) type, "getIntPropertyMap", arg);
+}
+
+#endif // ICU >= 63
static PyObject *t_char_getIntPropertyValue(PyTypeObject *type, PyObject *args)
{
@@ -988,6 +1035,53 @@
}
#endif // ICU >= 75
+/* UCPMap */
+
+#if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0)
+
+static PyObject *t_ucpmap_get(t_ucpmap *self, PyObject *arg)
+{
+ UChar32 c;
+
+ if (!parseArg(arg, "i", &c))
+ {
+ return PyInt_FromLong(ucpmap_get(self->object, c));
+ }
+
+ return PyErr_SetArgsError((PyObject *) self, "get", arg);
+}
+
+static PyObject *t_ucpmap_getRange(t_ucpmap *self, PyObject *args)
+{
+ UChar32 start;
+ int option, surrogateValue = 0;
+
+ switch (PyTuple_Size(args)) {
+ case 1:
+ if (!parseArgs(args, "i", &start))
+ {
+ return PyInt_FromLong(ucpmap_getRange(self->object, start,
UCPMAP_RANGE_NORMAL, 0, NULL, NULL, NULL));
+ }
+ break;
+ case 2:
+ if (!parseArgs(args, "ii", &start, &option))
+ {
+ return PyInt_FromLong(ucpmap_getRange(self->object, start,
(UCPMapRangeOption) option, (uint32_t) surrogateValue, NULL, NULL, NULL));
+ }
+ break;
+ case 3:
+ if (!parseArgs(args, "iii", &start, &option, &surrogateValue))
+ {
+ return PyInt_FromLong(ucpmap_getRange(self->object, start,
(UCPMapRangeOption) option, (uint32_t) surrogateValue, NULL, NULL, NULL));
+ }
+ break;
+ }
+
+ return PyErr_SetArgsError((PyObject *) self, "getRange", args);
+}
+
+#endif // ICU >= 63
+
void _init_char(PyObject *m)
{
@@ -1009,12 +1103,17 @@
INSTALL_CONSTANTS_TYPE(UIndicPositionalCategory, m);
INSTALL_CONSTANTS_TYPE(UIndicSyllabicCategory, m);
INSTALL_CONSTANTS_TYPE(UVerticalOrientation, m);
+ INSTALL_CONSTANTS_TYPE(UCPMapRangeOption, m);
#endif
#if U_ICU_VERSION_HEX >= VERSION_HEX(75, 0, 0)
INSTALL_CONSTANTS_TYPE(UIdentifierType, m);
INSTALL_CONSTANTS_TYPE(UIdentifierStatus, m);
#endif
+
INSTALL_STRUCT(Char, m);
+#if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0)
+ INSTALL_STRUCT(UCPMap, m);
+#endif
INSTALL_ENUM(Char, "FOLD_CASE_DEFAULT", U_FOLD_CASE_DEFAULT);
INSTALL_ENUM(Char, "FOLD_CASE_EXCLUDE_SPECIAL_I",
U_FOLD_CASE_EXCLUDE_SPECIAL_I);
@@ -1079,6 +1178,7 @@
#endif
INSTALL_ENUM(UProperty, "BIDI_CLASS", UCHAR_BIDI_CLASS);
INSTALL_ENUM(UProperty, "INT_START", UCHAR_INT_START);
+ INSTALL_ENUM(UProperty, "INT_LIMIT", UCHAR_INT_LIMIT);
INSTALL_ENUM(UProperty, "BLOCK", UCHAR_BLOCK);
INSTALL_ENUM(UProperty, "CANONICAL_COMBINING_CLASS",
UCHAR_CANONICAL_COMBINING_CLASS);
INSTALL_ENUM(UProperty, "DECOMPOSITION_TYPE", UCHAR_DECOMPOSITION_TYPE);
@@ -1154,6 +1254,11 @@
INSTALL_ENUM(UProperty, "RGI_EMOJI_ZWJ_SEQUENCE",
UCHAR_RGI_EMOJI_ZWJ_SEQUENCE);
INSTALL_ENUM(UProperty, "RGI_EMOJI", UCHAR_RGI_EMOJI);
#endif
+#if U_ICU_VERSION_HEX >= VERSION_HEX(74, 0, 0)
+ INSTALL_ENUM(UProperty, "IDS_UNARY_OPERATOR", UCHAR_IDS_UNARY_OPERATOR);
+ INSTALL_ENUM(UProperty, "ID_COMPAT_MATH_START",
UCHAR_ID_COMPAT_MATH_START);
+ INSTALL_ENUM(UProperty, "ID_COMPAT_MATH_CONTINUE",
UCHAR_ID_COMPAT_MATH_CONTINUE);
+#endif
#if U_ICU_VERSION_HEX >= VERSION_HEX(75, 0, 0)
INSTALL_ENUM(UProperty, "IDENTIFIER_STATUS", UCHAR_IDENTIFIER_STATUS);
INSTALL_ENUM(UProperty, "IDENTIFIER_TYPE", UCHAR_IDENTIFIER_TYPE);
@@ -1577,6 +1682,17 @@
#if U_ICU_VERSION_HEX >= VERSION_HEX(74, 0, 0)
INSTALL_ENUM(UBlockCode, "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_I",
UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_I);
#endif
+#if U_ICU_VERSION_HEX >= VERSION_HEX(76, 0, 0)
+ INSTALL_ENUM(UBlockCode, "EGYPTIAN_HIEROGLYPHS_EXTENDED_A",
UBLOCK_EGYPTIAN_HIEROGLYPHS_EXTENDED_A);
+ INSTALL_ENUM(UBlockCode, "GARAY", UBLOCK_GARAY);
+ INSTALL_ENUM(UBlockCode, "GURUNG_KHEMA", UBLOCK_GURUNG_KHEMA);
+ INSTALL_ENUM(UBlockCode, "MYANMAR_EXTENDED_C", UBLOCK_MYANMAR_EXTENDED_C);
+ INSTALL_ENUM(UBlockCode, "OL_ONAL", UBLOCK_OL_ONAL);
+ INSTALL_ENUM(UBlockCode, "SUNUWAR", UBLOCK_SUNUWAR);
+ INSTALL_ENUM(UBlockCode, "SYMBOLS_FOR_LEGACY_COMPUTING_SUPPLEMENT",
UBLOCK_SYMBOLS_FOR_LEGACY_COMPUTING_SUPPLEMENT);
+ INSTALL_ENUM(UBlockCode, "TODHRI", UBLOCK_TODHRI);
+ INSTALL_ENUM(UBlockCode, "TULU_TIGALARI", UBLOCK_TULU_TIGALARI);
+#endif
INSTALL_ENUM(UBlockCode, "INVALID_CODE", UBLOCK_INVALID_CODE);
INSTALL_ENUM(UCharNameChoice, "UNICODE_CHAR_NAME", U_UNICODE_CHAR_NAME);
@@ -1650,11 +1766,18 @@
INSTALL_ENUM(UIndicSyllabicCategory, "VOWEL", U_INSC_VOWEL);
INSTALL_ENUM(UIndicSyllabicCategory, "VOWEL_DEPENDENT",
U_INSC_VOWEL_DEPENDENT);
INSTALL_ENUM(UIndicSyllabicCategory, "VOWEL_INDEPENDENT",
U_INSC_VOWEL_INDEPENDENT);
-
+#if U_ICU_VERSION_HEX >= VERSION_HEX(76, 0, 0)
+ INSTALL_ENUM(UIndicSyllabicCategory, "REORDERING_KILLER",
U_INSC_REORDERING_KILLER);
+#endif
+
INSTALL_ENUM(UVerticalOrientation, "ROTATED", U_VO_ROTATED);
INSTALL_ENUM(UVerticalOrientation, "TRANSFORMED_ROTATED",
U_VO_TRANSFORMED_ROTATED);
INSTALL_ENUM(UVerticalOrientation, "TRANSFORMED_UPRIGHT",
U_VO_TRANSFORMED_UPRIGHT);
INSTALL_ENUM(UVerticalOrientation, "UPRIGHT", U_VO_UPRIGHT);
+
+ INSTALL_ENUM(UCPMapRangeOption, "NORMAL", UCPMAP_RANGE_NORMAL);
+ INSTALL_ENUM(UCPMapRangeOption, "FIXED_LEAD_SURROGATES",
UCPMAP_RANGE_FIXED_LEAD_SURROGATES);
+ INSTALL_ENUM(UCPMapRangeOption, "FIXED_ALL_SURROGATES",
UCPMAP_RANGE_FIXED_ALL_SURROGATES);
#endif // ICU >= 63
#if U_ICU_VERSION_HEX >= 0x04000000
@@ -1754,6 +1877,9 @@
INSTALL_ENUM(UJoiningGroup, "THIN_YEH", U_JG_THIN_YEH);
INSTALL_ENUM(UJoiningGroup, "VERTICAL_TAIL", U_JG_VERTICAL_TAIL);
#endif
+#if U_ICU_VERSION_HEX >= VERSION_HEX(76, 0, 0)
+ INSTALL_ENUM(UJoiningGroup, "KASHMIRI_YEH", U_JG_KASHMIRI_YEH);
+#endif
INSTALL_ENUM(ULineBreak, "INSEPARABLE", U_LB_INSEPARABLE);
INSTALL_ENUM(ULineBreak, "NEXT_LINE", U_LB_NEXT_LINE);
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyicu-2.13.1/charset.cpp new/pyicu-2.14/charset.cpp
--- old/pyicu-2.13.1/charset.cpp 2021-04-01 23:28:41.000000000 +0200
+++ new/pyicu-2.14/charset.cpp 2024-10-03 03:36:21.000000000 +0200
@@ -251,7 +251,7 @@
static PyObject *t_charsetdetector_enableInputFilter(t_charsetdetector *self,
PyObject *arg)
{
- UBool filter;
+ int filter;
if (!parseArg(arg, "B", &filter))
{
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyicu-2.13.1/locale.cpp new/pyicu-2.14/locale.cpp
--- old/pyicu-2.13.1/locale.cpp 2023-12-22 13:49:23.000000000 +0100
+++ new/pyicu-2.14/locale.cpp 2024-10-02 03:23:47.000000000 +0200
@@ -91,6 +91,7 @@
static PyObject *t_locale_createKeywords(t_locale *self);
#if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0)
static PyObject *t_locale_createUnicodeKeywords(t_locale *self);
+static PyObject *t_locale_getUnicodeKeywordValue(t_locale *self, PyObject
*arg);
#endif
static PyObject *t_locale_getKeywordValue(t_locale *self, PyObject *arg);
#if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0)
@@ -160,11 +161,12 @@
DECLARE_METHOD(t_locale, createKeywords, METH_NOARGS),
#if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0)
DECLARE_METHOD(t_locale, createUnicodeKeywords, METH_NOARGS),
+ DECLARE_METHOD(t_locale, getUnicodeKeywordValue, METH_O),
#endif
+ DECLARE_METHOD(t_locale, getKeywordValue, METH_O),
#if U_ICU_VERSION_HEX >= VERSION_HEX(67, 0, 0)
DECLARE_METHOD(t_locale, canonicalize, METH_NOARGS),
#endif
- DECLARE_METHOD(t_locale, getKeywordValue, METH_O),
#if U_ICU_VERSION_HEX >= VERSION_HEX(49, 0, 0)
DECLARE_METHOD(t_locale, setKeywordValue, METH_VARARGS),
DECLARE_METHOD(t_locale, removeKeywordValue, METH_O),
@@ -1266,6 +1268,27 @@
return PyUnicode_FromUnicodeString(&buffer.u);
}
+static PyObject *t_locale_getUnicodeKeywordValue(t_locale *self, PyObject *arg)
+{
+ struct sink {
+ UnicodeString u;
+ void append(const char *data, int32_t n)
+ {
+ u.append(UnicodeString(data, n, US_INV));
+ }
+ } buffer;
+ StringByteSink<struct sink> sbs(&buffer);
+ charsArg name;
+
+ if (!parseArg(arg, "n", &name))
+ {
+ STATUS_CALL(self->object->getUnicodeKeywordValue(name.c_str(), sbs,
status))
+ return PyUnicode_FromUnicodeString(&buffer.u);
+ }
+
+ return PyErr_SetArgsError((PyObject *) self, "getUnicodeKeywordValue",
arg);
+}
+
#endif // ICU >= 63
#if U_ICU_VERSION_HEX >= VERSION_HEX(67, 0, 0)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyicu-2.13.1/py/PyICU.egg-info/PKG-INFO
new/pyicu-2.14/py/PyICU.egg-info/PKG-INFO
--- old/pyicu-2.13.1/py/PyICU.egg-info/PKG-INFO 2024-04-29 22:17:30.000000000
+0200
+++ new/pyicu-2.14/py/PyICU.egg-info/PKG-INFO 2024-10-26 10:44:06.000000000
+0200
@@ -1,6 +1,6 @@
Metadata-Version: 2.1
Name: PyICU
-Version: 2.13.1
+Version: 2.14
Summary: Python extension wrapping the ICU C++ API
Home-page: https://gitlab.pyicu.org/main/pyicu
Author: Andi Vajda
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyicu-2.13.1/py/PyICU.egg-info/SOURCES.txt
new/pyicu-2.14/py/PyICU.egg-info/SOURCES.txt
--- old/pyicu-2.13.1/py/PyICU.egg-info/SOURCES.txt 2024-04-29
22:17:30.000000000 +0200
+++ new/pyicu-2.14/py/PyICU.egg-info/SOURCES.txt 2024-10-26
10:44:06.000000000 +0200
@@ -95,6 +95,7 @@
test/test_Normalizer.py
test/test_NumberFormat.py
test/test_NumberFormatter.py
+test/test_Property.py
test/test_PythonReplaceable.py
test/test_Regex.py
test/test_Script.py
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyicu-2.13.1/regex.cpp new/pyicu-2.14/regex.cpp
--- old/pyicu-2.13.1/regex.cpp 2023-08-25 20:28:53.000000000 +0200
+++ new/pyicu-2.14/regex.cpp 2024-10-03 03:36:45.000000000 +0200
@@ -669,7 +669,7 @@
static PyObject *t_regexmatcher_useTransparentBounds(t_regexmatcher *self,
PyObject *arg)
{
- UBool b;
+ int b;
if (!parseArg(arg, "B", &b))
{
@@ -689,7 +689,7 @@
static PyObject *t_regexmatcher_useAnchoringBounds(t_regexmatcher *self,
PyObject *arg)
{
- UBool b;
+ int b;
if (!parseArg(arg, "B", &b))
{
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyicu-2.13.1/setup.py new/pyicu-2.14/setup.py
--- old/pyicu-2.13.1/setup.py 2024-04-29 22:14:33.000000000 +0200
+++ new/pyicu-2.14/setup.py 2024-10-26 10:19:34.000000000 +0200
@@ -8,8 +8,8 @@
from distutils.spawn import find_executable
-VERSION = '2.13.1'
-ICU_MAX_MAJOR_VERSION = '75' # max supported major version of ICU
+VERSION = '2.14'
+ICU_MAX_MAJOR_VERSION = '76' # max supported major version of ICU
try:
from subprocess import check_output as subprocess_check_output
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyicu-2.13.1/test/test_NumberFormatter.py
new/pyicu-2.14/test/test_NumberFormatter.py
--- old/pyicu-2.13.1/test/test_NumberFormatter.py 2021-10-04
20:48:52.000000000 +0200
+++ new/pyicu-2.14/test/test_NumberFormatter.py 2024-10-02 03:00:51.000000000
+0200
@@ -125,15 +125,27 @@
if ICU_VERSION < '63.0':
self.skipTest(ICU_VERSION)
- def testBasic(self):
+ if ICU_VERSION < '76.0':
+ def testBasic(self):
- text = NumberRangeFormatter.withLocale(Locale.getItaly()) \
- .formatIntRange(1234, 5678)
- self.assertEqual(text, u'1.234-5.678')
-
- text = LocalizedNumberRangeFormatter(Locale.getItaly()) \
- .formatIntRange(1234, 5678)
- self.assertEqual(text, u'1.234-5.678')
+ text = NumberRangeFormatter.withLocale(Locale.getItaly()) \
+ .formatIntRange(1234, 5678)
+ self.assertEqual(text, u'1.234-5.678')
+
+ text = LocalizedNumberRangeFormatter(Locale.getItaly()) \
+ .formatIntRange(1234, 5678)
+ self.assertEqual(text, u'1.234-5.678')
+
+ if ICU_VERSION >= '76.0':
+ def testBasic(self):
+
+ text = NumberRangeFormatter.withLocale(Locale.getItaly()) \
+ .formatIntRange(1234, 5678)
+ self.assertEqual(text, u'1234-5678')
+
+ text = LocalizedNumberRangeFormatter(Locale.getItaly()) \
+ .formatIntRange(1234, 5678)
+ self.assertEqual(text, u'1234-5678')
def testFormattedNumberRange(self):
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyicu-2.13.1/test/test_Property.py
new/pyicu-2.14/test/test_Property.py
--- old/pyicu-2.13.1/test/test_Property.py 1970-01-01 01:00:00.000000000
+0100
+++ new/pyicu-2.14/test/test_Property.py 2024-07-04 11:19:58.000000000
+0200
@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+# ====================================================================
+# Copyright (c) 2024 Open Source Applications Foundation.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+# ====================================================================
+#
+
+from unittest import TestCase, main
+from icu import *
+
+class TestIntPropertyMap(TestCase):
+
+ def setUp(self):
+ if ICU_VERSION < '63.0':
+ self.skipTest(ICU_VERSION)
+
+ def testGet(self):
+
+ eastAsianWidthMap = Char.getIntPropertyMap(UProperty.EAST_ASIAN_WIDTH)
+ self.assertEqual(0, eastAsianWidthMap.get(ord('à¤'))) # Neutral
+ self.assertEqual(1, eastAsianWidthMap.get(ord('â'))) # Ambiguous
+ self.assertEqual(2, eastAsianWidthMap.get(ord('ｶ'))) # Halfwidth
+ self.assertEqual(3, eastAsianWidthMap.get(ord('ï½'))) # Fullwidth
+ self.assertEqual(4, eastAsianWidthMap.get(ord('a'))) # Narrow
+ self.assertEqual(5, eastAsianWidthMap.get(ord('ð'))) # Wide
+
+ def testGetRange(self):
+ eastAsianWidthMap = Char.getIntPropertyMap(UProperty.EAST_ASIAN_WIDTH)
+ self.assertEqual(42124, eastAsianWidthMap.getRange(ord('\u4E00')))
+
+
+if __name__ == "__main__":
+ main()
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/pyicu-2.13.1/test/test_TimeZone.py
new/pyicu-2.14/test/test_TimeZone.py
--- old/pyicu-2.13.1/test/test_TimeZone.py 2023-09-11 21:10:34.000000000
+0200
+++ new/pyicu-2.14/test/test_TimeZone.py 2024-10-03 03:38:26.000000000
+0200
@@ -35,12 +35,18 @@
self.assertTrue(isinstance(tz, BasicTimeZone))
self.assertEqual(str(tz), "America/Los_Angeles")
- def testGetRegion(self):
+ if ICU_VERSION >= '4.8' and ICU_VERSION < '76.0':
+ def testGetRegion(self):
- if ICU_VERSION >= '4.8':
self.assertEqual('US', TimeZone.getRegion("America/Los_Angeles"))
self.assertEqual('001', TimeZone.getRegion("CET"))
+ if ICU_VERSION >= '76.0':
+ def testGetRegion(self):
+
+ self.assertEqual('US', TimeZone.getRegion("America/Los_Angeles"))
+ self.assertEqual('BE', TimeZone.getRegion("CET"))
+
def testGetRules(self):
tz = TimeZone.createTimeZone("America/Los_Angeles")
