pyicu 2.15.2__tar.gz → 2.16__tar.gz

{pyicu-2.15.2 → pyicu-2.16}/CHANGES

@@ -1,3 +1,20 @@
+Issues can be seen at https://gitlab.pyicu.org/main/pyicu/-/issues/<num>
+
+Version 2.15.3 -> 2.16
+----------------------
+  - fixed issue #178
+  - added new enums from new unicode release in UBlockCode, UScriptCode
+  - added missing wrappers for ECollationStrength and EComparisonResult
+  - added wrapper for UIndicConjunctBreak
+  - added support for ICU 78.1
+
+Version 2.15.2 -> 2.15.3
+------------------------
+  - replaced all malloc/calloc/free with std::unique_ptr<T[]>
+  - fixed issue #173
+  - fixed issue #175
+  - fixed issue #176
+
 Version 2.15.1 -> 2.15.2
 ------------------------
   - fixed calloc/free mismatch with arg::Q() uses (Fredrik Roubert)

{pyicu-2.15.2 → pyicu-2.16}/CREDITS

@@ -3,7 +3,7 @@ PyICU is a Python extension wrapping Unicode Consortium's ICU library and
 wouldn't be possible without the tireless efforts of the people and open source
 projects below.
 
-  - the ICU developers: http://icu-project.org
+  - the ICU developers: http://icu.unicode.org
 
   - the Open Source Applications Foundation, for hosting the project at its
     inception, in 2004: http://www.osafoundation.org
@@ -19,6 +19,7 @@ projects below.
   - Markus Scherer for various bug fixes (see CHANGES)
   - Martin Hosken for bug fixes (see CHANGES)
   - Roman Kalukiewicz for MessagePattern
+  - Martin Jansche for argument parsing and validation with modern C++
   - 
 
 Thank you all !

{pyicu-2.15.2/py/PyICU.egg-info → pyicu-2.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyicu
-Version: 2.15.2
+Version: 2.16
 Summary: Python extension wrapping the ICU C++ API
 Home-page: https://gitlab.pyicu.org/main/pyicu
 Author: Andi Vajda

{pyicu-2.15.2 → pyicu-2.16}/arg.h

@@ -24,6 +24,7 @@
 #ifndef _arg_h
 #define _arg_h
 
+#include <memory>
 #include <type_traits>
 
 #include "common.h"
@@ -385,13 +386,13 @@ template <typename T> class ICUObjectArray {
 private:
     const classid id;
     PyTypeObject *const type;
-    std::unique_ptr<T *, decltype(free) *> *const array;
+    std::unique_ptr<T *[]> *const array;
     size_t *const len;
 
 public:
     ICUObjectArray() = delete;
 
-    explicit ICUObjectArray(classid param1, PyTypeObject *param2, std::unique_ptr<T *, decltype(free) *> *param3, size_t *param4) noexcept
+    explicit ICUObjectArray(classid param1, PyTypeObject *param2, std::unique_ptr<T *[]> *param3, size_t *param4) noexcept
         : id(param1), type(param2), array(param3), len(param4) {}
 
     int parse(PyObject *arg) const
@@ -409,7 +410,7 @@ public:
                 return -1;
         }
 
-        array->reset(reinterpret_cast<T **>(pl2cpa(arg, len, id, type)));
+        *array = pl2cpa<T>(arg, len, id, type);
         if (!array->get())
             return -1;
 
@@ -853,7 +854,7 @@ public:
 };
 
 #define _IS_POD(T)                                      \
-  static_assert(std::is_trivial<T>::value);             \
+  static_assert(std::is_trivially_copyable<T>::value);  \
   static_assert(std::is_standard_layout<T>::value)
 
 _IS_POD(AnyPythonObject);

{pyicu-2.15.2 → pyicu-2.16}/bidi.cpp

@@ -672,17 +672,12 @@ static PyObject *t_bidi_getLogicalMap(t_bidi *self)
     else
         length = ubidi_getProcessedLength(self->object);
 
-    int *indexMap = (int *) calloc(length, sizeof(int));
+    std::unique_ptr<int[]> indexMap(new int[length]);
 
-    if (indexMap == NULL)
+    if (!indexMap.get())
         return PyErr_NoMemory();
 
-    STATUS_CALL(
-        {
-            ubidi_getLogicalMap(self->object, indexMap, &status);
-            if (U_FAILURE(status))
-                free(indexMap);
-        });
+    STATUS_CALL(ubidi_getLogicalMap(self->object, indexMap.get(), &status));
 
     PyObject *result = PyTuple_New(length);
 
@@ -691,7 +686,6 @@ static PyObject *t_bidi_getLogicalMap(t_bidi *self)
         for (int i = 0; i < length; ++i)
             PyTuple_SET_ITEM(result, i, PyInt_FromLong(indexMap[i]));
     }
-    free(indexMap);
 
     return result;
 }
@@ -705,17 +699,12 @@ static PyObject *t_bidi_getVisualMap(t_bidi *self)
     else
         length = ubidi_getResultLength(self->object);
 
-    int *indexMap = (int *) calloc(length, sizeof(int));
+    std::unique_ptr<int[]> indexMap(new int[length]);
 
-    if (indexMap == NULL)
+    if (!indexMap.get())
         return PyErr_NoMemory();
 
-    STATUS_CALL(
-        {
-            ubidi_getVisualMap(self->object, indexMap, &status);
-            if (U_FAILURE(status))
-                free(indexMap);
-        });
+    STATUS_CALL(ubidi_getVisualMap(self->object, indexMap.get(), &status));
 
     PyObject *result = PyTuple_New(length);
 
@@ -724,7 +713,6 @@ static PyObject *t_bidi_getVisualMap(t_bidi *self)
         for (int i = 0; i < length; ++i)
             PyTuple_SET_ITEM(result, i, PyInt_FromLong(indexMap[i]));
     }
-    free(indexMap);
 
     return result;
 }
@@ -736,12 +724,12 @@ static PyObject *t_bidi_reorderLogical(PyTypeObject *type, PyObject *arg)
 
     if (!parseArg(arg, arg::H(&levels, &length)))
     {
-        int *indexMap = (int *) calloc(length, sizeof(int));
+        std::unique_ptr<int[]> indexMap(new int[length]);
 
-        if (indexMap == NULL)
+        if (!indexMap.get())
             return PyErr_NoMemory();
 
-        ubidi_reorderLogical((const UBiDiLevel *) levels.get(), length, indexMap);
+        ubidi_reorderLogical((const UBiDiLevel *) levels.get(), length, indexMap.get());
 
         PyObject *result = PyTuple_New(length);
 
@@ -750,7 +738,6 @@ static PyObject *t_bidi_reorderLogical(PyTypeObject *type, PyObject *arg)
             for (size_t i = 0; i < length; ++i)
                 PyTuple_SET_ITEM(result, i, PyInt_FromLong(indexMap[i]));
         }
-        free(indexMap);
 
         return result;
     }
@@ -765,12 +752,12 @@ static PyObject *t_bidi_reorderVisual(PyTypeObject *type, PyObject *arg)
 
     if (!parseArg(arg, arg::H(&levels, &length)))
     {
-        int *indexMap = (int *) calloc(length, sizeof(int));
+        std::unique_ptr<int[]> indexMap(new int[length]);
 
-        if (indexMap == NULL)
+        if (!indexMap.get())
             return PyErr_NoMemory();
 
-        ubidi_reorderVisual((const UBiDiLevel *) levels.get(), length, indexMap);
+        ubidi_reorderVisual((const UBiDiLevel *) levels.get(), length, indexMap.get());
 
         PyObject *result = PyTuple_New(length);
 
@@ -779,7 +766,6 @@ static PyObject *t_bidi_reorderVisual(PyTypeObject *type, PyObject *arg)
             for (size_t i = 0; i < length; ++i)
                 PyTuple_SET_ITEM(result, i, PyInt_FromLong(indexMap[i]));
         }
-        free(indexMap);
 
         return result;
     }
@@ -801,12 +787,12 @@ static PyObject *t_bidi_invertMap(PyTypeObject *type, PyObject *arg)
                 maxSrc = srcMap[i];
 
         int destLength = maxSrc + 1;
-        int *destMap = (int *) calloc(destLength, sizeof(int));
+        std::unique_ptr<int[]> destMap(new int[destLength]);
 
-        if (destMap == NULL)
+        if (!destMap.get())
             return PyErr_NoMemory();
 
-        ubidi_invertMap((const int *) srcMap.get(), destMap, srcLength);
+        ubidi_invertMap((const int *) srcMap.get(), destMap.get(), srcLength);
 
         PyObject *result = PyTuple_New(destLength);
 
@@ -815,7 +801,6 @@ static PyObject *t_bidi_invertMap(PyTypeObject *type, PyObject *arg)
             for (int i = 0; i < destLength; ++i)
                 PyTuple_SET_ITEM(result, i, PyInt_FromLong(destMap[i]));
         }
-        free(destMap);
 
         return result;
     }

{pyicu-2.15.2 → pyicu-2.16}/char.cpp

@@ -1,5 +1,5 @@
 /* ====================================================================
- * Copyright (c) 2004-2024 Open Source Applications Foundation.
+ * Copyright (c) 2004-2025 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"),
@@ -58,6 +58,9 @@ DECLARE_CONSTANTS_TYPE(UCPMapRangeOption)
 DECLARE_CONSTANTS_TYPE(UIdentifierType)
 DECLARE_CONSTANTS_TYPE(UIdentifierStatus)
 #endif
+#if U_ICU_VERSION_HEX >= VERSION_HEX(76, 0, 0)
+DECLARE_CONSTANTS_TYPE(UIndicConjunctBreak)
+#endif
 
 /* Char */
 
@@ -1151,6 +1154,9 @@ void _init_char(PyObject *m)
     INSTALL_CONSTANTS_TYPE(UIdentifierType, m);
     INSTALL_CONSTANTS_TYPE(UIdentifierStatus, m);
 #endif
+#if U_ICU_VERSION_HEX >= VERSION_HEX(76, 0, 0)
+    INSTALL_CONSTANTS_TYPE(UIndicConjunctBreak, m);
+#endif    
 
     INSTALL_STRUCT(Char, m);
 #if U_ICU_VERSION_HEX >= VERSION_HEX(63, 0, 0)
@@ -1166,6 +1172,7 @@ void _init_char(PyObject *m)
     INSTALL_ENUM(UProperty, "BIDI_MIRRORED", UCHAR_BIDI_MIRRORED);
     INSTALL_ENUM(UProperty, "DASH", UCHAR_DASH);
     INSTALL_ENUM(UProperty, "DEFAULT_IGNORABLE_CODE_POINT", UCHAR_DEFAULT_IGNORABLE_CODE_POINT);
+    INSTALL_ENUM(UProperty, "DEPRECATED", UCHAR_DEPRECATED);
     INSTALL_ENUM(UProperty, "DIACRITIC", UCHAR_DIACRITIC);
     INSTALL_ENUM(UProperty, "EXTENDER", UCHAR_EXTENDER);
     INSTALL_ENUM(UProperty, "FULL_COMPOSITION_EXCLUSION", UCHAR_FULL_COMPOSITION_EXCLUSION);
@@ -1305,7 +1312,11 @@ void _init_char(PyObject *m)
     INSTALL_ENUM(UProperty, "IDENTIFIER_STATUS", UCHAR_IDENTIFIER_STATUS);
     INSTALL_ENUM(UProperty, "IDENTIFIER_TYPE", UCHAR_IDENTIFIER_TYPE);
 #endif
-    INSTALL_ENUM(UProperty, "INVALID_CODE ", UCHAR_INVALID_CODE );
+#if U_ICU_VERSION_HEX >= VERSION_HEX(76, 0, 0)
+    INSTALL_ENUM(UProperty, "INDIC_CONJUNCT_BREAK", UCHAR_INDIC_CONJUNCT_BREAK);
+    INSTALL_ENUM(UProperty, "MODIFIER_COMBINING_MARK", UCHAR_MODIFIER_COMBINING_MARK);
+#endif
+    INSTALL_ENUM(UProperty, "INVALID_CODE", UCHAR_INVALID_CODE);
 
     INSTALL_ENUM(UCharDirection, "LEFT_TO_RIGHT", U_LEFT_TO_RIGHT);
     INSTALL_ENUM(UCharDirection, "RIGHT_TO_LEFT", U_RIGHT_TO_LEFT);
@@ -1734,6 +1745,16 @@ void _init_char(PyObject *m)
     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
+#if U_ICU_VERSION_HEX >= VERSION_HEX(78, 0, 0)
+    INSTALL_ENUM(UBlockCode, "BERIA_ERFE", UBLOCK_BERIA_ERFE);
+    INSTALL_ENUM(UBlockCode, "CJK_UNIFIED_IDEOGRAPHS_EXTENSION_J", UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_J);
+    INSTALL_ENUM(UBlockCode, "MISCELLANEOUS_SYMBOLS_SUPPLEMENT", UBLOCK_MISCELLANEOUS_SYMBOLS_SUPPLEMENT);
+    INSTALL_ENUM(UBlockCode, "SHARADA_SUPPLEMENT", UBLOCK_SHARADA_SUPPLEMENT);
+    INSTALL_ENUM(UBlockCode, "SIDETIC", UBLOCK_SIDETIC);
+    INSTALL_ENUM(UBlockCode, "TAI_YO", UBLOCK_TAI_YO);
+    INSTALL_ENUM(UBlockCode, "TANGUT_COMPONENTS_SUPPLEMENT", UBLOCK_TANGUT_COMPONENTS_SUPPLEMENT);
+    INSTALL_ENUM(UBlockCode, "TOLONG_SIKI", UBLOCK_TOLONG_SIKI);
 #endif
     INSTALL_ENUM(UBlockCode, "INVALID_CODE", UBLOCK_INVALID_CODE);
 
@@ -1811,6 +1832,13 @@ void _init_char(PyObject *m)
 #if U_ICU_VERSION_HEX >= VERSION_HEX(76, 0, 0)
     INSTALL_ENUM(UIndicSyllabicCategory, "REORDERING_KILLER", U_INSC_REORDERING_KILLER);
 #endif
+
+#if U_ICU_VERSION_HEX >= VERSION_HEX(76, 0, 0)
+    INSTALL_ENUM(UIndicConjunctBreak, "CONSONANT", U_INCB_CONSONANT);
+    INSTALL_ENUM(UIndicConjunctBreak, "EXTEND", U_INCB_EXTEND);
+    INSTALL_ENUM(UIndicConjunctBreak, "LINKER", U_INCB_LINKER);
+    INSTALL_ENUM(UIndicConjunctBreak, "NONE", U_INCB_NONE);
+#endif    
     
     INSTALL_ENUM(UVerticalOrientation, "ROTATED", U_VO_ROTATED);
     INSTALL_ENUM(UVerticalOrientation, "TRANSFORMED_ROTATED", U_VO_TRANSFORMED_ROTATED);
@@ -1922,6 +1950,9 @@ void _init_char(PyObject *m)
 #if U_ICU_VERSION_HEX >= VERSION_HEX(76, 0, 0)
     INSTALL_ENUM(UJoiningGroup, "KASHMIRI_YEH", U_JG_KASHMIRI_YEH);
 #endif
+#if U_ICU_VERSION_HEX >= VERSION_HEX(78, 0, 0)
+    INSTALL_ENUM(UJoiningGroup, "THIN_NOON", U_JG_THIN_NOON);
+#endif
 
     INSTALL_ENUM(ULineBreak, "INSEPARABLE", U_LB_INSEPARABLE);
     INSTALL_ENUM(ULineBreak, "NEXT_LINE", U_LB_NEXT_LINE);
@@ -1952,6 +1983,9 @@ void _init_char(PyObject *m)
     INSTALL_ENUM(ULineBreak, "VIRAMA_FINAL", U_LB_VIRAMA_FINAL);
     INSTALL_ENUM(ULineBreak, "VIRAMA", U_LB_VIRAMA);
 #endif
+#if U_ICU_VERSION_HEX >= VERSION_HEX(78, 0, 0)
+    INSTALL_ENUM(ULineBreak, "UNAMBIGUOUS_HYPHEN", U_LB_UNAMBIGUOUS_HYPHEN);
+#endif
 
     INSTALL_ENUM(UGraphemeClusterBreak, "OTHER", U_GCB_OTHER);
     INSTALL_ENUM(UGraphemeClusterBreak, "CONTROL", U_GCB_CONTROL);

{pyicu-2.15.2 → pyicu-2.16}/collator.cpp

@@ -34,6 +34,8 @@
 #include "arg.h"
 
 DECLARE_CONSTANTS_TYPE(UCollationResult)
+DECLARE_CONSTANTS_TYPE(ECollationStrength)
+DECLARE_CONSTANTS_TYPE(EComparisonResult)
 DECLARE_CONSTANTS_TYPE(UCollAttribute)
 DECLARE_CONSTANTS_TYPE(UCollAttributeValue)
 #if U_ICU_VERSION_HEX >= 0x04080000
@@ -536,7 +538,7 @@ static PyObject *t_collator_getSortKey(t_collator *self, PyObject *args)
     UnicodeString *u;
     UnicodeString _u;
     int len, size;
-    uint8_t *buf;
+    std::unique_ptr<uint8_t[]> buf;
     PyObject *key;
 
     switch (PyTuple_Size(args)) {
@@ -544,21 +546,18 @@ static PyObject *t_collator_getSortKey(t_collator *self, PyObject *args)
         if (!parseArgs(args, arg::S(&u, &_u)))
         {
             len = u->length() * 4 + 8;
-            buf = (uint8_t *) malloc(len);
+            buf.reset(new uint8_t[len]);
           retry:
-            if (buf == NULL)
+            if (!buf.get())
                 return PyErr_NoMemory();
 
-            size = self->object->getSortKey(*u, buf, len);
+            size = self->object->getSortKey(*u, buf.get(), len);
             if (size <= len)
-            {
-                key = PyBytes_FromStringAndSize((char *) buf, size);
-                free(buf);
-            }
+                key = PyBytes_FromStringAndSize((char *) buf.get(), size);
             else
             {
                 len = size;
-                buf = (uint8_t *) realloc(buf, len);
+                buf.reset(new uint8_t[len]);
                 goto retry;
             }
 
@@ -568,13 +567,12 @@ static PyObject *t_collator_getSortKey(t_collator *self, PyObject *args)
       case 2:
         if (!parseArgs(args, arg::S(&u, &_u), arg::i(&len)))
         {
-            buf = (uint8_t *) calloc(len, 1);
-            if (buf == NULL)
+            buf.reset(new uint8_t[len]);
+            if (!buf.get())
                 return PyErr_NoMemory();
 
-            len = self->object->getSortKey(*u, buf, len);
-            key = PyBytes_FromStringAndSize((char *) buf, len);
-            free(buf);
+            len = self->object->getSortKey(*u, buf.get(), len);
+            key = PyBytes_FromStringAndSize((char *) buf.get(), len);
 
             return key;
         }
@@ -1413,6 +1411,8 @@ void _init_collator(PyObject *m)
     ImmutableIndexType_.tp_as_sequence = &t_immutableindex_as_sequence;
 #endif
     INSTALL_CONSTANTS_TYPE(UCollationResult, m);
+    INSTALL_CONSTANTS_TYPE(ECollationStrength, m);
+    INSTALL_CONSTANTS_TYPE(EComparisonResult, m);
     INSTALL_CONSTANTS_TYPE(UCollAttribute, m);
     INSTALL_CONSTANTS_TYPE(UCollAttributeValue, m);
     REGISTER_TYPE(CollationKey, m);
@@ -1430,6 +1430,16 @@ void _init_collator(PyObject *m)
     INSTALL_ENUM(UCollationResult, "EQUAL", UCOL_EQUAL);
     INSTALL_ENUM(UCollationResult, "GREATER", UCOL_GREATER);
 
+    INSTALL_ENUM(ECollationStrength, "PRIMARY", UCOL_PRIMARY);
+    INSTALL_ENUM(ECollationStrength, "SECONDARY", UCOL_SECONDARY);
+    INSTALL_ENUM(ECollationStrength, "TERTIARY", UCOL_TERTIARY);
+    INSTALL_ENUM(ECollationStrength, "QUATERNARY", UCOL_QUATERNARY);
+    INSTALL_ENUM(ECollationStrength, "IDENTICAL", UCOL_IDENTICAL);
+
+    INSTALL_ENUM(EComparisonResult, "LESS", UCOL_LESS);
+    INSTALL_ENUM(EComparisonResult, "EQUAL", UCOL_EQUAL);
+    INSTALL_ENUM(EComparisonResult, "GREATER", UCOL_GREATER);
+
     INSTALL_ENUM(UCollAttribute, "FRENCH_COLLATION", UCOL_FRENCH_COLLATION);
     INSTALL_ENUM(UCollAttribute, "ALTERNATE_HANDLING", UCOL_ALTERNATE_HANDLING);
     INSTALL_ENUM(UCollAttribute, "CASE_FIRST", UCOL_CASE_FIRST);

{pyicu-2.15.2 → pyicu-2.16}/common.cpp

@@ -645,35 +645,6 @@ int isInstance(PyObject *arg, classid id, PyTypeObject *type)
     return 0;
 }
 
-UObject **pl2cpa(PyObject *arg, size_t *len, classid id, PyTypeObject *type)
-{
-    if (PySequence_Check(arg))
-    {
-        *len = (int) PySequence_Size(arg);
-        UObject **array = (UObject **) calloc(*len, sizeof(UObject *));
-
-        for (size_t i = 0; i < *len; i++) {
-            PyObject *obj = PySequence_GetItem(arg, i);
-
-            if (isInstance(obj, id, type))
-            {
-                array[i] = ((t_uobject *) obj)->object;
-                Py_DECREF(obj);
-            }
-            else
-            {
-                Py_DECREF(obj);
-                free(array);
-                return NULL;
-            }
-        }
-
-        return array;
-    }
-
-    return NULL;
-}
-
 PyObject *cpa2pl(UObject **array, size_t len, PyObject *(*wrap)(UObject *, int))
 {
     PyObject *list = PyList_New(len);

{pyicu-2.15.2 → pyicu-2.16}/common.h

@@ -449,7 +449,42 @@ Formattable *toFormattable(PyObject *arg);
 Formattable *toFormattableArray(PyObject *arg, size_t *len,
                                 classid id, PyTypeObject *type);
 
-UObject **pl2cpa(PyObject *arg, size_t *len, classid id, PyTypeObject *type);
+#include "bases.h"
+
+template <typename T>
+std::unique_ptr<T *[]> pl2cpa(PyObject *arg, size_t *len, classid id, PyTypeObject *type)
+{
+    std::unique_ptr<T *[]> array;
+
+    if (PySequence_Check(arg))
+    {
+        *len = (int) PySequence_Size(arg);
+        array.reset(new T *[*len]);
+        if (!array.get())
+            PyErr_NoMemory();
+        else
+        {
+            for (size_t i = 0; i < *len; i++) {
+                PyObject *obj = PySequence_GetItem(arg, i);
+
+                if (isInstance(obj, id, type))
+                {
+                    array[i] = reinterpret_cast<T *>(((t_uobject *) obj)->object);
+                    Py_DECREF(obj);
+                }
+                else
+                {
+                    Py_DECREF(obj);
+                    array.reset(nullptr);
+                    break;
+                }
+            }
+        }
+    }
+
+    return array;
+}
+
 PyObject *cpa2pl(UObject **array, size_t len, PyObject *(*wrap)(UObject *, int));
 
 int *toIntArray(PyObject *arg, size_t *len);

{pyicu-2.15.2 → pyicu-2.16}/format.cpp

@@ -964,7 +964,7 @@ static PyObject *t_measureformat_formatMeasure(t_measureformat *self,
 static PyObject *t_measureformat_formatMeasures(t_measureformat *self,
                                                 PyObject *args)
 {
-    std::unique_ptr<Measure *, decltype(free) *> measures(NULL, free);
+    std::unique_ptr<Measure *[]> measures;
     size_t len;
     FieldPosition dont_care(FieldPosition::DONT_CARE);
     FieldPosition *fp;
@@ -1288,7 +1288,7 @@ static PyObject *t_messageformat_getFormats(t_messageformat *self)
 static PyObject *t_messageformat_setFormats(t_messageformat *self,
                                             PyObject *arg)
 {
-    std::unique_ptr<Format *, decltype(free) *> formats(NULL, free);
+    std::unique_ptr<Format *[]> formats;
     size_t len;
 
     if (!parseArg(arg, arg::Q<Format>(TYPE_ID(Format), &formats, &len)))

{pyicu-2.15.2 → pyicu-2.16}/iterators.cpp

@@ -1142,33 +1142,25 @@ static PyObject *t_breakiterator_getRuleStatusVec(t_breakiterator *self)
 
     if (status == U_BUFFER_OVERFLOW_ERROR)
     {
-        int32_t *buffer = (int32_t *) calloc(count, sizeof(int32_t));
+        std::unique_ptr<int32_t[]> buffer(new int32_t[count]);
 
-        if (buffer == NULL)
+        if (!buffer.get())
             return PyErr_NoMemory();
 
         status = U_ZERO_ERROR;
-        count = self->object->getRuleStatusVec(buffer, count, status);
+        count = self->object->getRuleStatusVec(buffer.get(), count, status);
 
         if (U_FAILURE(status))
-        {
-            free(buffer);
             return ICUException(status).reportError();
-        }
 
         PyObject *tuple = PyTuple_New(count);
 
         if (!tuple)
-        {
-            free(buffer);
             return NULL;
-        }
 
         for (int i = 0; i < count; ++i)
             PyTuple_SET_ITEM(tuple, i, PyInt_FromLong(buffer[i]));
 
-        free(buffer);
-
         return tuple;
     }
 

{pyicu-2.15.2 → pyicu-2.16}/locale.cpp

@@ -2253,33 +2253,25 @@ static PyObject *t_localebuilder_build(t_localebuilder *self)
 
 #if U_ICU_VERSION_HEX >= VERSION_HEX(65, 0, 0)
 
-// takes ownership of locales pointer array
 class LocaleIterator : public Locale::Iterator {
   public:
-    LocaleIterator(Locale **locales, int len) :
-        locales_(locales), len_(len),
-        current_(0)
+    LocaleIterator(std::unique_ptr<Locale *[]> &&locales, int len) :
+        locales(std::move(locales)), len(len), current(0)
     {}
 
-    ~LocaleIterator()
-    {
-        free(locales_);  // allocated with calloc in pl2cpa in common.cpp
-    }
-
     UBool hasNext() const override
     {
-        return current_ < len_;
+        return current < len;
     }
 
     const Locale &next() override
     {
-        return *locales_[current_++];
+        return *locales[current++];
     }
 
   private:
-    Locale **locales_;
-    int len_;
-    int current_;
+    std::unique_ptr<Locale *[]> locales;
+    int len, current;
 };
 
 
@@ -2322,12 +2314,12 @@ static PyObject *t_localematcherbuilder_setSupportedLocalesFromListString(
 static PyObject *t_localematcherbuilder_setSupportedLocales(
     t_localematcherbuilder *self, PyObject *arg)
 {
-    std::unique_ptr<Locale *, decltype(free) *> locales(NULL, free);
+    std::unique_ptr<Locale *[]> locales;
     size_t len;
 
     if (!parseArg(arg, arg::Q<Locale>(TYPE_CLASSID(Locale), &locales, &len)))
     {
-        LocaleIterator it(locales.release(), len);
+        LocaleIterator it(std::move(locales), len);
 
         self->object->setSupportedLocales(it);
         Py_RETURN_SELF();
@@ -2499,7 +2491,7 @@ static PyObject *t_localematcher_getBestMatch(t_localematcher *self,
                                               PyObject *arg)
 {
     Locale *locale;
-    std::unique_ptr<Locale *, decltype(free) *> locales(NULL, free);
+    std::unique_ptr<Locale *[]> locales;
     size_t len;
 
     if (!parseArg(arg, arg::P<Locale>(TYPE_CLASSID(Locale), &locale)))
@@ -2512,7 +2504,7 @@ static PyObject *t_localematcher_getBestMatch(t_localematcher *self,
 
     if (!parseArg(arg, arg::Q<Locale>(TYPE_CLASSID(Locale), &locales, &len)))
     {
-        LocaleIterator it(locales.release(), len);
+        LocaleIterator it(std::move(locales), len);
         const Locale *result;
 
         STATUS_CALL(result = self->object->getBestMatch(it, status));
@@ -2546,7 +2538,7 @@ static PyObject *t_localematcher_getBestMatchResult(
     t_localematcher *self, PyObject *arg)
 {
     Locale *locale;
-    std::unique_ptr<Locale *, decltype(free) *> locales(NULL, free);
+    std::unique_ptr<Locale *[]> locales;
     size_t len;
 
     if (!parseArg(arg, arg::P<Locale>(TYPE_CLASSID(Locale), &locale)))
@@ -2559,7 +2551,7 @@ static PyObject *t_localematcher_getBestMatchResult(
 
     if (!parseArg(arg, arg::Q<Locale>(TYPE_CLASSID(Locale), &locales, &len)))
     {
-        LocaleIterator it(locales.release(), len);
+        LocaleIterator it(std::move(locales), len);
 
         STATUS_RESULT_CALL(
             LocaleMatcherResult result = self->object->getBestMatchResult(
@@ -2608,17 +2600,11 @@ static PyObject *t_localematcher_acceptLanguage(PyTypeObject *type,
                        arg::m(&accepts, &num_accepts),
                        arg::m(&locales, &num_locales)))
         {
-            const char **accept_buffers =
-                (const char **) calloc(num_accepts, sizeof(char *));
-            const char **locale_buffers =
-                (const char **) calloc(num_locales, sizeof(char *));
+            std::unique_ptr<const char *[]> accept_buffers(new const char *[num_accepts]);
+            std::unique_ptr<const char *[]> locale_buffers(new const char *[num_locales]);
 
-            if (!accept_buffers || !locale_buffers)
-            {
-                free(locale_buffers);
-                free(accept_buffers);
+            if (!accept_buffers.get() || !locale_buffers.get())
                 return PyErr_NoMemory();
-            }
 
             for (size_t i = 0; i < num_accepts; ++i)
                 accept_buffers[i] = accepts[i].c_str();
@@ -2628,14 +2614,10 @@ static PyObject *t_localematcher_acceptLanguage(PyTypeObject *type,
 
             UErrorCode status = U_ZERO_ERROR;
             UEnumeration *locale_enum = uenum_openCharStringsEnumeration(
-                locale_buffers, num_locales, &status);
+                locale_buffers.get(), num_locales, &status);
 
             if (U_FAILURE(status))
-            {
-                free(locale_buffers);
-                free(accept_buffers);
                 return ICUException(status).reportError();
-            }
             else
                 status = U_ZERO_ERROR;
 
@@ -2643,11 +2625,9 @@ static PyObject *t_localematcher_acceptLanguage(PyTypeObject *type,
             char buffer[128];
             size_t size = uloc_acceptLanguage(
                 buffer, sizeof(buffer), &result,
-                accept_buffers, num_accepts, locale_enum, &status);
+                accept_buffers.get(), num_accepts, locale_enum, &status);
 
             uenum_close(locale_enum);
-            free(locale_buffers);
-            free(accept_buffers);
 
             if (U_FAILURE(status))
                 return ICUException(status).reportError();
@@ -2682,10 +2662,9 @@ static PyObject *t_localematcher_acceptLanguageFromHTTP(PyTypeObject *type,
                        arg::n(&header_value),
                        arg::m(&locales, &num_locales)))
         {
-            const char **locale_buffers =
-                (const char **) calloc(num_locales, sizeof(char *));
+            std::unique_ptr<const char *[]> locale_buffers(new const char *[num_locales]);
 
-            if (!locale_buffers)
+            if (!locale_buffers.get())
                 return PyErr_NoMemory();
 
             for (size_t i = 0; i < num_locales; ++i)
@@ -2693,13 +2672,10 @@ static PyObject *t_localematcher_acceptLanguageFromHTTP(PyTypeObject *type,
 
             UErrorCode status = U_ZERO_ERROR;
             UEnumeration *locale_enum = uenum_openCharStringsEnumeration(
-                locale_buffers, num_locales, &status);
+                locale_buffers.get(), num_locales, &status);
 
             if (U_FAILURE(status))
-            {
-                free(locale_buffers);
                 return ICUException(status).reportError();
-            }
             else
                 status = U_ZERO_ERROR;
 
@@ -2710,7 +2686,6 @@ static PyObject *t_localematcher_acceptLanguageFromHTTP(PyTypeObject *type,
                 header_value.c_str(), locale_enum, &status);
 
             uenum_close(locale_enum);
-            free(locale_buffers);
 
             if (U_FAILURE(status))
                 return ICUException(status).reportError();
@@ -3003,11 +2978,23 @@ void _init_locale(PyObject *m)
 
     INSTALL_ENUM(ULocaleDataExemplarSetType, "ES_STANDARD",
                  ULOCDATA_ES_STANDARD);
+    INSTALL_ENUM(ULocaleDataExemplarSetType, "STANDARD",
+                 ULOCDATA_ES_STANDARD);
     INSTALL_ENUM(ULocaleDataExemplarSetType, "ES_AUXILIARY",
                  ULOCDATA_ES_AUXILIARY);
+    INSTALL_ENUM(ULocaleDataExemplarSetType, "AUXILIARY",
+                 ULOCDATA_ES_AUXILIARY);
 #if U_ICU_VERSION_HEX >= 0x04080000
     INSTALL_ENUM(ULocaleDataExemplarSetType, "ES_INDEX",
                  ULOCDATA_ES_INDEX);
+    INSTALL_ENUM(ULocaleDataExemplarSetType, "INDEX",
+                 ULOCDATA_ES_INDEX);
+#endif
+#if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0)
+    INSTALL_ENUM(ULocaleDataExemplarSetType, "ES_PUNCTUATION",
+                 ULOCDATA_ES_PUNCTUATION);
+    INSTALL_ENUM(ULocaleDataExemplarSetType, "PUNCTUATION",
+                 ULOCDATA_ES_PUNCTUATION);
 #endif
 
     INSTALL_ENUM(UMeasurementSystem, "SI", UMS_SI);

{pyicu-2.15.2 → pyicu-2.16}/measureunit.cpp

@@ -297,12 +297,21 @@ static PyObject *t_measureunit_createBeaufort(PyTypeObject *type);
 static PyObject *t_measureunit_createGasolineEnergyDensity(PyTypeObject *type);
 #endif
 
+#if U_ICU_VERSION_HEX >= VERSION_HEX(76, 0, 0)
+static PyObject *t_measureunit_createLightSpeed(PyTypeObject *type);
+static PyObject *t_measureunit_createNight(PyTypeObject *type);
+#endif
+
 #if U_ICU_VERSION_HEX >= VERSION_HEX(77, 0, 0)
-static PyObject *t_measureunit_createPortionPer1E9(PyTypeObject *type);
 static PyObject *t_measureunit_withConstantDenominator(t_measureunit *self, PyObject *arg);
 static PyObject *t_measureunit_getConstantDenominator(t_measureunit *self);
 #endif
 
+#if U_ICU_VERSION_HEX >= VERSION_HEX(78, 0, 0)
+static PyObject *t_measureunit_createPartPer1E6(PyTypeObject *type);
+static PyObject *t_measureunit_createPartPer1E9(PyTypeObject *type);
+#endif
+
 static PyMethodDef t_measureunit_methods[] = {
 #if U_ICU_VERSION_HEX >= VERSION_HEX(53, 0, 0)
     DECLARE_METHOD(t_measureunit, getType, METH_NOARGS),
@@ -543,10 +552,17 @@ static PyMethodDef t_measureunit_methods[] = {
 #if U_ICU_VERSION_HEX >= VERSION_HEX(74, 0, 0)
     DECLARE_METHOD(t_measureunit, createGasolineEnergyDensity, METH_NOARGS | METH_CLASS),
 #endif
+#if U_ICU_VERSION_HEX >= VERSION_HEX(76, 0, 0)
+    DECLARE_METHOD(t_measureunit, createLightSpeed, METH_NOARGS | METH_CLASS),
+    DECLARE_METHOD(t_measureunit, createNight, METH_NOARGS | METH_CLASS),
+#endif
 #if U_ICU_VERSION_HEX >= VERSION_HEX(77, 0, 0)
-    DECLARE_METHOD(t_measureunit, createPortionPer1E9, METH_NOARGS | METH_CLASS),
     DECLARE_METHOD(t_measureunit, withConstantDenominator, METH_O),
     DECLARE_METHOD(t_measureunit, getConstantDenominator, METH_NOARGS),
+#endif
+#if U_ICU_VERSION_HEX >= VERSION_HEX(78, 0, 0)
+    DECLARE_METHOD(t_measureunit, createPartPer1E6, METH_NOARGS | METH_CLASS),
+    DECLARE_METHOD(t_measureunit, createPartPer1E9, METH_NOARGS | METH_CLASS),
 #endif
     { NULL, NULL, 0, NULL }
 };
@@ -1174,8 +1190,14 @@ createMU(Beaufort)
 createMU(GasolineEnergyDensity)
 #endif
 
-#if U_ICU_VERSION_HEX >= VERSION_HEX(77, 0, 0)
-createMU(PortionPer1E9)
+#if U_ICU_VERSION_HEX >= VERSION_HEX(76, 0, 0)
+createMU(LightSpeed)
+createMU(Night)
+#endif
+
+#if U_ICU_VERSION_HEX >= VERSION_HEX(78, 0, 0)
+createMU(PartPer1E6)
+createMU(PartPer1E9)
 #endif
 
 /* Measure */

{pyicu-2.15.2 → pyicu-2.16/py/PyICU.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyicu
-Version: 2.15.2
+Version: 2.16
 Summary: Python extension wrapping the ICU C++ API
 Home-page: https://gitlab.pyicu.org/main/pyicu
 Author: Andi Vajda

{pyicu-2.15.2 → pyicu-2.16}/script.cpp

@@ -594,6 +594,13 @@ void _init_script(PyObject *m)
 #if U_ICU_VERSION_HEX >= VERSION_HEX(75, 0, 0)
     INSTALL_ENUM(UScriptCode, "ARABIC_NASTALIQ", USCRIPT_ARABIC_NASTALIQ);
 #endif
+#if U_ICU_VERSION_HEX >= VERSION_HEX(78, 0, 0)
+    INSTALL_ENUM(UScriptCode, "BERIA_ERFE", USCRIPT_BERIA_ERFE);
+    INSTALL_ENUM(UScriptCode, "SIDETIC", USCRIPT_SIDETIC);
+    INSTALL_ENUM(UScriptCode, "TAI_YO", USCRIPT_TAI_YO);
+    INSTALL_ENUM(UScriptCode, "TOLONG_SIKI", USCRIPT_TOLONG_SIKI);
+    INSTALL_ENUM(UScriptCode, "TRADITIONAL_HAN_WITH_LATIN", USCRIPT_TRADITIONAL_HAN_WITH_LATIN);
+#endif
 
 #if U_ICU_VERSION_HEX >= VERSION_HEX(51, 0, 0)
     INSTALL_ENUM(UScriptUsage, "NOT_ENCODED", USCRIPT_USAGE_NOT_ENCODED);

{pyicu-2.15.2 → pyicu-2.16}/setup.py

@@ -8,8 +8,8 @@ except ImportError:
 
 from distutils.spawn import find_executable
 
-VERSION = '2.15.2'
-ICU_MAX_MAJOR_VERSION = '77'  # max supported major version of ICU
+VERSION = '2.16'
+ICU_MAX_MAJOR_VERSION = '78'  # max supported major version of ICU
 
 try:
     from subprocess import check_output as subprocess_check_output

{pyicu-2.15.2 → pyicu-2.16}/timezone.cpp

@@ -1419,33 +1419,25 @@ static PyObject *t_basictimezone_getTimeZoneRules(t_basictimezone *self)
     STATUS_CALL(count = self->object->countTransitionRules(status));
 
     const InitialTimeZoneRule *initial;
-    const TimeZoneRule **rules =
-        (const TimeZoneRule **) calloc(count, sizeof(const TimeZoneRule *));
-    if (rules == NULL)
+    std::unique_ptr<const TimeZoneRule *[]> rules(new const TimeZoneRule *[count]);
+    if (!rules.get())
         return PyErr_NoMemory();
 
     UErrorCode status = U_ZERO_ERROR;
 
-    self->object->getTimeZoneRules(initial, rules, count, status);
+    self->object->getTimeZoneRules(initial, rules.get(), count, status);
     if (U_FAILURE(status))
-    {
-        free(rules);
         return ICUException(status).reportError();
-    }
 
     PyObject *result = PyTuple_New(count + 1);
 
     if (result == NULL)
-    {
-        free(rules);
         return NULL;
-    }
 
     PyTuple_SET_ITEM(result, 0, wrap_TimeZoneRule(*initial));
     for (int i = 0; i < count; ++i)
       PyTuple_SET_ITEM(result, i + 1, wrap_TimeZoneRule(*rules[i]));
 
-    free(rules);
     return result;
 }