icu4py 0.2.0__cp314-cp314-manylinux_2_26_i686.manylinux_2_28_i686.whl

icu4py/__init__.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from icu4py._version import icu_version, icu_version_info
+else:
+    from typing import Any
+
+    def __getattr__(name: str) -> Any:
+        if name == "icu_version":
+            from icu4py._version import icu_version
+
+            return icu_version
+        elif name == "icu_version_info":
+            from icu4py._version import icu_version_info
+
+            return icu_version_info
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = ["icu_version", "icu_version_info"]

icu4py/_version.cpp

@@ -0,0 +1,57 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <unicode/uversion.h>
+
+namespace {
+
+PyMethodDef version_module_methods[] = {
+    {nullptr, nullptr, 0, nullptr}
+};
+
+int icu4py_version_exec(PyObject* m) {
+    UVersionInfo versionArray;
+    u_getVersion(versionArray);
+
+    PyObject* version_tuple = Py_BuildValue("(iiii)",
+        versionArray[0],
+        versionArray[1],
+        versionArray[2],
+        versionArray[3]
+    );
+    if (PyModule_AddObject(m, "icu_version_info", version_tuple) < 0) {
+        Py_DECREF(version_tuple);
+        return -1;
+    }
+
+    if (PyModule_AddStringConstant(m, "icu_version", U_ICU_VERSION) < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+PyModuleDef_Slot version_slots[] = {
+    {Py_mod_exec, reinterpret_cast<void*>(icu4py_version_exec)},
+#ifdef Py_GIL_DISABLED
+    {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+#endif
+    {0, nullptr}
+};
+
+static PyModuleDef versionmodule = {
+    PyModuleDef_HEAD_INIT,
+    "icu4py._version",
+    "ICU version information",
+    0,
+    version_module_methods,
+    version_slots,
+    nullptr,
+    nullptr,
+    nullptr,
+};
+
+}  // anonymous namespace
+
+PyMODINIT_FUNC PyInit__version() {
+    return PyModuleDef_Init(&versionmodule);
+}

icu4py/_version.pyi

@@ -0,0 +1,4 @@
+from __future__ import annotations
+
+icu_version: str
+icu_version_info: tuple[int, int, int, int]

icu4py/locale.cpp

@@ -0,0 +1,267 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <string>
+#include <unicode/locid.h>
+#include <unicode/strenum.h>
+#include "locale_types.h"
+
+namespace {
+
+using icu::Locale;
+using icu4py::LocaleObject;
+
+void Locale_dealloc(LocaleObject* self) {
+    delete self->locale;
+    Py_TYPE(self)->tp_free(reinterpret_cast<PyObject*>(self));
+}
+
+PyObject* Locale_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
+    auto* self = reinterpret_cast<LocaleObject*>(type->tp_alloc(type, 0));
+    if (self != nullptr) {
+        self->locale = nullptr;
+    }
+    return reinterpret_cast<PyObject*>(self);
+}
+
+int Locale_init(LocaleObject* self, PyObject* args, PyObject* kwds) {
+    const char* language = nullptr;
+    const char* country = nullptr;
+    const char* variant = nullptr;
+    PyObject* extensions = nullptr;
+
+    static const char* kwlist[] = {"language", "country", "variant", "extensions", nullptr};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|zzO",
+                                     const_cast<char**>(kwlist),
+                                     &language, &country, &variant, &extensions)) {
+        return -1;
+    }
+
+    const char* keywords_and_values = nullptr;
+    std::string keywords_str;
+
+    if (extensions != nullptr && extensions != Py_None) {
+        if (!PyDict_Check(extensions)) {
+            PyErr_SetString(PyExc_TypeError, "extensions must be a dict or None");
+            return -1;
+        }
+
+        Py_ssize_t pos = 0;
+        PyObject* key;
+        PyObject* value;
+        bool first = true;
+        bool err = false;
+
+#ifdef Py_GIL_DISABLED
+        Py_BEGIN_CRITICAL_SECTION(extensions);
+#endif
+
+        while (PyDict_Next(extensions, &pos, &key, &value)) {
+            if (!PyUnicode_Check(key)) {
+                PyErr_SetString(PyExc_TypeError, "extension keys must be strings");
+                err = true;
+                break;
+            }
+            if (!PyUnicode_Check(value)) {
+                PyErr_SetString(PyExc_TypeError, "extension values must be strings");
+                err = true;
+                break;
+            }
+
+            const char* key_str = PyUnicode_AsUTF8(key);
+            if (key_str == nullptr) {
+              err = true;
+              break;
+            }
+            const char* value_str = PyUnicode_AsUTF8(value);
+            if (value_str == nullptr) {
+              err = true;
+              break;
+            }
+
+            if (!first) {
+                keywords_str += ";";
+            }
+            keywords_str += key_str;
+            keywords_str += "=";
+            keywords_str += value_str;
+            first = false;
+        }
+#ifdef Py_GIL_DISABLED
+        Py_END_CRITICAL_SECTION();
+#endif
+        if (err) {
+            return -1;
+        }
+
+        if (!keywords_str.empty()) {
+            keywords_and_values = keywords_str.c_str();
+        }
+    }
+
+    self->locale = new Locale(language, country, variant, keywords_and_values);
+
+    return 0;
+}
+
+PyObject* Locale_get_bogus(LocaleObject* self, void* closure) {
+    if (self->locale->isBogus()) {
+        Py_RETURN_TRUE;
+    }
+    Py_RETURN_FALSE;
+}
+
+PyObject* Locale_get_language(LocaleObject* self, void* closure) {
+    const char* language = self->locale->getLanguage();
+    return PyUnicode_FromString(language);
+}
+
+PyObject* Locale_get_country(LocaleObject* self, void* closure) {
+    const char* country = self->locale->getCountry();
+    return PyUnicode_FromString(country);
+}
+
+PyObject* Locale_get_variant(LocaleObject* self, void* closure) {
+    const char* variant = self->locale->getVariant();
+    return PyUnicode_FromString(variant);
+}
+
+PyObject* Locale_get_extensions(LocaleObject* self, void* closure) {
+    UErrorCode status = U_ZERO_ERROR;
+    icu::StringEnumeration* keywords = self->locale->createKeywords(status);
+
+    if (U_FAILURE(status) || keywords == nullptr) {
+        return PyDict_New();
+    }
+
+    PyObject* dict = PyDict_New();
+    if (dict == nullptr) {
+        delete keywords;
+        return nullptr;
+    }
+
+    const char* keyword;
+    while ((keyword = keywords->next(nullptr, status)) != nullptr) {
+        if (U_FAILURE(status)) {
+            break;
+        }
+
+        std::string value_str;
+        const int32_t capacity = 256;
+        char buffer[capacity];
+
+        int32_t length = self->locale->getKeywordValue(keyword, buffer, capacity, status);
+        if (U_FAILURE(status)) {
+            break;
+        }
+
+        value_str.assign(buffer, length);
+
+        PyObject* key_obj = PyUnicode_FromString(keyword);
+        PyObject* value_obj = PyUnicode_FromString(value_str.c_str());
+
+        if (key_obj == nullptr || value_obj == nullptr) {
+            Py_XDECREF(key_obj);
+            Py_XDECREF(value_obj);
+            Py_DECREF(dict);
+            delete keywords;
+            return nullptr;
+        }
+
+        if (PyDict_SetItem(dict, key_obj, value_obj) < 0) {
+            Py_DECREF(key_obj);
+            Py_DECREF(value_obj);
+            Py_DECREF(dict);
+            delete keywords;
+            return nullptr;
+        }
+
+        Py_DECREF(key_obj);
+        Py_DECREF(value_obj);
+    }
+
+    delete keywords;
+
+    if (U_FAILURE(status)) {
+        Py_DECREF(dict);
+        PyErr_SetString(PyExc_RuntimeError, "Failed to retrieve keywords");
+        return nullptr;
+    }
+
+    return dict;
+}
+
+PyGetSetDef Locale_getsetters[] = {
+    {const_cast<char*>("bogus"), reinterpret_cast<getter>(Locale_get_bogus), nullptr,
+     const_cast<char*>("Whether the locale is bogus"), nullptr},
+    {const_cast<char*>("language"), reinterpret_cast<getter>(Locale_get_language), nullptr,
+     const_cast<char*>("The locale's ISO-639 language code"), nullptr},
+    {const_cast<char*>("country"), reinterpret_cast<getter>(Locale_get_country), nullptr,
+     const_cast<char*>("The locale's ISO-3166 country code"), nullptr},
+    {const_cast<char*>("variant"), reinterpret_cast<getter>(Locale_get_variant), nullptr,
+     const_cast<char*>("The locale's variant code"), nullptr},
+    {const_cast<char*>("extensions"), reinterpret_cast<getter>(Locale_get_extensions), nullptr,
+     const_cast<char*>("The locale's keywords and values"), nullptr},
+    {nullptr, nullptr, nullptr, nullptr, nullptr}
+};
+
+PyType_Slot Locale_slots[] = {
+    {Py_tp_doc, const_cast<char*>("ICU Locale")},
+    {Py_tp_dealloc, reinterpret_cast<void*>(Locale_dealloc)},
+    {Py_tp_init, reinterpret_cast<void*>(Locale_init)},
+    {Py_tp_new, reinterpret_cast<void*>(Locale_new)},
+    {Py_tp_getset, Locale_getsetters},
+    {0, nullptr}
+};
+
+PyType_Spec Locale_spec = {
+    "icu4py.locale.Locale",
+    sizeof(LocaleObject),
+    0,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+    Locale_slots
+};
+
+PyMethodDef locale_module_methods[] = {
+    {nullptr, nullptr, 0, nullptr}
+};
+
+int icu4py_locale_exec(PyObject* m) {
+    PyObject* type_obj = PyType_FromModuleAndSpec(m, &Locale_spec, nullptr);
+    if (type_obj == nullptr) {
+        return -1;
+    }
+
+    if (PyModule_AddObject(m, "Locale", type_obj) < 0) {
+        Py_DECREF(type_obj);
+        return -1;
+    }
+
+    return 0;
+}
+
+PyModuleDef_Slot locale_slots[] = {
+    {Py_mod_exec, reinterpret_cast<void*>(icu4py_locale_exec)},
+#ifdef Py_GIL_DISABLED
+    {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+#endif
+    {0, nullptr}
+};
+
+static PyModuleDef localemodule = {
+    PyModuleDef_HEAD_INIT,
+    "icu4py.locale",
+    "",
+    0,
+    locale_module_methods,
+    locale_slots,
+    nullptr,
+    nullptr,
+    nullptr,
+};
+
+}  // anonymous namespace
+
+PyMODINIT_FUNC PyInit_locale() {
+    return PyModuleDef_Init(&localemodule);
+}

icu4py/locale.pyi

@@ -0,0 +1,26 @@
+from typing import overload
+
+from typing_extensions import disjoint_base
+
+@disjoint_base
+class Locale:
+    @overload
+    def __init__(self, language: str) -> None: ...
+    @overload
+    def __init__(
+        self,
+        language: str,
+        country: str,
+        variant: str | None = None,
+        extensions: dict[str, str] | None = None,
+    ) -> None: ...
+    @property
+    def bogus(self) -> bool: ...
+    @property
+    def language(self) -> str: ...
+    @property
+    def country(self) -> str: ...
+    @property
+    def variant(self) -> str: ...
+    @property
+    def extensions(self) -> dict[str, str]: ...

icu4py/messageformat.cpp

@@ -0,0 +1,522 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <unicode/msgfmt.h>
+#include <unicode/unistr.h>
+#include <unicode/fmtable.h>
+#include <unicode/locid.h>
+#include <unicode/parsepos.h>
+#include <unicode/ustring.h>
+#include <unicode/utypes.h>
+
+#include <cstring>
+#include <memory>
+
+#include "locale_types.h"
+
+namespace {
+
+using icu::MessageFormat;
+using icu::UnicodeString;
+using icu::Formattable;
+using icu::Locale;
+using icu::FieldPosition;
+using icu::StringPiece;
+using icu4py::LocaleObject;
+
+struct ModuleState {
+    PyObject* datetime_datetime_type;
+    PyObject* datetime_date_type;
+    PyObject* datetime_time_type;
+    PyObject* decimal_decimal_type;
+    PyObject* locale_type;
+};
+
+static inline ModuleState* get_module_state(PyObject* module) {
+    void* state = PyModule_GetState(module);
+    return static_cast<ModuleState*>(state);
+}
+
+int icu4py_messageformat_exec(PyObject* m);
+int icu4py_messageformat_traverse(PyObject* m, visitproc visit, void* arg);
+int icu4py_messageformat_clear(PyObject* m);
+
+PyMethodDef icu4py_messageformat_module_methods[] = {
+    {nullptr, nullptr, 0, nullptr}
+};
+
+PyModuleDef_Slot icu4py_messageformat_slots[] = {
+    {Py_mod_exec, reinterpret_cast<void*>(icu4py_messageformat_exec)},
+// On Python 3.13+, declare free-threaded support.
+// https://py-free-threading.github.io/porting-extensions/#declaring-free-threaded-support
+#ifdef Py_GIL_DISABLED
+    {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+#endif
+    {0, nullptr}
+};
+
+static PyModuleDef icu4pymodule = {
+    PyModuleDef_HEAD_INIT,
+    "icu4py.messageformat",
+    "",
+    sizeof(ModuleState),
+    icu4py_messageformat_module_methods,
+    icu4py_messageformat_slots,
+    icu4py_messageformat_traverse,
+    icu4py_messageformat_clear,
+    nullptr,
+};
+
+struct MessageFormatObject {
+    PyObject_HEAD
+    MessageFormat* formatter;
+};
+
+void MessageFormat_dealloc(MessageFormatObject* self) {
+    delete self->formatter;
+    Py_TYPE(self)->tp_free(reinterpret_cast<PyObject*>(self));
+}
+
+PyObject* MessageFormat_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
+    auto* self = reinterpret_cast<MessageFormatObject*>(type->tp_alloc(type, 0));
+    if (self != nullptr) {
+        self->formatter = nullptr;
+    }
+    return reinterpret_cast<PyObject*>(self);
+}
+
+int MessageFormat_init(MessageFormatObject* self, PyObject* args, PyObject* kwds) {
+    const char* pattern;
+    PyObject* locale_obj;
+    Py_ssize_t pattern_len;
+
+    static const char* kwlist[] = {"pattern", "locale", nullptr};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#O",
+                                     const_cast<char**>(kwlist),
+                                     &pattern, &pattern_len, &locale_obj)) {
+        return -1;
+    }
+
+#if PY_VERSION_HEX < 0x030B0000
+    PyObject* module = _PyType_GetModuleByDef(Py_TYPE(self), &icu4pymodule);
+#else
+    PyObject* module = PyType_GetModuleByDef(Py_TYPE(self), &icu4pymodule);
+#endif
+    if (module == nullptr) {
+        return -1;
+    }
+    ModuleState* mod_state = get_module_state(module);
+
+    UErrorCode status = U_ZERO_ERROR;
+    UnicodeString upattern = UnicodeString::fromUTF8(StringPiece(pattern, pattern_len));
+    Locale locale;
+
+    if (PyUnicode_Check(locale_obj)) {
+        const char* locale_str = PyUnicode_AsUTF8(locale_obj);
+        if (locale_str == nullptr) {
+            return -1;
+        }
+        locale = Locale(locale_str);
+    } else {
+        int is_locale = PyObject_IsInstance(locale_obj, mod_state->locale_type);
+        if (is_locale == -1) {
+            return -1;
+        }
+        if (is_locale == 0) {
+            PyErr_SetString(PyExc_TypeError, "locale must be a string or Locale object");
+            return -1;
+        }
+
+        LocaleObject* locale_pyobj = reinterpret_cast<LocaleObject*>(locale_obj);
+        if (locale_pyobj->locale == nullptr) {
+            PyErr_SetString(PyExc_ValueError, "Locale object has null internal locale");
+            return -1;
+        }
+        locale = *locale_pyobj->locale;
+    }
+
+    self->formatter = new MessageFormat(upattern, locale, status);
+
+    if (U_FAILURE(status)) {
+        delete self->formatter;
+        self->formatter = nullptr;
+        PyErr_Format(PyExc_ValueError, "Failed to create MessageFormat: %s",
+                     u_errorName(status));
+        return -1;
+    }
+
+    return 0;
+}
+
+bool pyobject_to_formattable(PyObject* obj, Formattable& formattable, ModuleState* state) {
+    if (PyLong_Check(obj)) {
+        int overflow;
+        long long long_val = PyLong_AsLongLongAndOverflow(obj, &overflow);
+        if (overflow != 0) {
+            PyObject* str_obj = PyObject_Str(obj);
+            if (str_obj == nullptr) {
+                return false;
+            }
+            Py_ssize_t size;
+            const char* str_val = PyUnicode_AsUTF8AndSize(str_obj, &size);
+            if (str_val == nullptr) {
+                Py_DECREF(str_obj);
+                return false;
+            }
+            UErrorCode status = U_ZERO_ERROR;
+            formattable = Formattable(StringPiece(str_val, size), status);
+            Py_DECREF(str_obj);
+            if (U_FAILURE(status)) {
+                PyErr_Format(PyExc_ValueError, "Failed to create Formattable from overflowed int: %s",
+                              u_errorName(status));
+                return false;
+            }
+            return true;
+        }
+        if (long_val == -1 && PyErr_Occurred()) {
+            return false;
+        }
+        formattable = Formattable(static_cast<int64_t>(long_val));
+        return true;
+    }
+
+      if (PyUnicode_Check(obj)) {
+          Py_ssize_t size;
+          const char* str_val = PyUnicode_AsUTF8AndSize(obj, &size);
+          if (str_val == nullptr) {
+              return false;
+          }
+          formattable = Formattable(UnicodeString::fromUTF8(StringPiece(str_val, size)));
+          return true;
+      }
+
+      if (PyFloat_Check(obj)) {
+          double dbl_val = PyFloat_AsDouble(obj);
+          if (dbl_val == -1.0 && PyErr_Occurred()) {
+              return false;
+          }
+          formattable = Formattable(dbl_val);
+          return true;
+      }
+
+      int is_decimal = PyObject_IsInstance(obj, state->decimal_decimal_type);
+      if (is_decimal == -1) {
+          return false;
+      } else if (is_decimal == 1) {
+          PyObject* str_obj = PyObject_Str(obj);
+          if (str_obj == nullptr) {
+              return false;
+          }
+          Py_ssize_t size;
+          const char* str_val = PyUnicode_AsUTF8AndSize(str_obj, &size);
+          if (str_val == nullptr) {
+              Py_DECREF(str_obj);
+              return false;
+          }
+          UErrorCode status = U_ZERO_ERROR;
+          formattable = Formattable(StringPiece(str_val, size), status);
+          Py_DECREF(str_obj);
+          if (U_FAILURE(status)) {
+              PyErr_Format(PyExc_ValueError, "Failed to create Formattable from Decimal: %s",
+                            u_errorName(status));
+              return false;
+          }
+          return true;
+      }
+
+      int is_datetime = PyObject_IsInstance(obj, state->datetime_datetime_type);
+      if (is_datetime == -1) {
+          return false;
+      } else if (is_datetime == 1) {
+          PyObject* timestamp = PyObject_CallMethod(obj, "timestamp", nullptr);
+          if (timestamp == nullptr) {
+              return false;
+          }
+          double timestamp_seconds = PyFloat_AsDouble(timestamp);
+          Py_DECREF(timestamp);
+          if (timestamp_seconds == -1.0 && PyErr_Occurred()) {
+              return false;
+          }
+          UDate udate = timestamp_seconds * 1000.0;
+          formattable = Formattable(udate, Formattable::kIsDate);
+          return true;
+      }
+
+      int is_date = PyObject_IsInstance(obj, state->datetime_date_type);
+      if (is_date == -1) {
+          return false;
+      } else if (is_date == 1) {
+          PyObject* combine = PyObject_GetAttrString(state->datetime_datetime_type, "combine");
+          if (combine == nullptr) {
+              return false;
+          }
+
+          PyObject* min_time = PyObject_GetAttrString(state->datetime_time_type, "min");
+          if (min_time == nullptr) {
+              Py_DECREF(combine);
+              return false;
+          }
+
+          PyObject* dt = PyObject_CallFunctionObjArgs(combine, obj, min_time, nullptr);
+          Py_DECREF(combine);
+          Py_DECREF(min_time);
+          if (dt == nullptr) {
+              return false;
+          }
+
+          PyObject* timestamp = PyObject_CallMethod(dt, "timestamp", nullptr);
+          Py_DECREF(dt);
+          if (timestamp == nullptr) {
+              return false;
+          }
+          double timestamp_seconds = PyFloat_AsDouble(timestamp);
+          Py_DECREF(timestamp);
+          if (timestamp_seconds == -1.0 && PyErr_Occurred()) {
+              return false;
+          }
+          UDate udate = timestamp_seconds * 1000.0;
+          formattable = Formattable(udate, Formattable::kIsDate);
+          return true;
+      }
+
+      PyErr_SetString(PyExc_TypeError, "Parameter values must be int, float, str, Decimal, datetime, or date");
+      return false;
+}
+
+bool dict_to_parallel_arrays(PyObject* dict, ModuleState* mod_state, UnicodeString*& names,
+                             Formattable*& values, int32_t& count) {
+    if (!PyDict_Check(dict)) {
+        PyErr_SetString(PyExc_TypeError, "Argument must be a dictionary");
+        return false;
+    }
+
+    count = static_cast<int32_t>(PyDict_Size(dict));
+    if (count == 0) {
+        names = nullptr;
+        values = nullptr;
+        return true;
+    }
+
+    auto names_ptr = std::make_unique<UnicodeString[]>(count);
+    auto values_ptr = std::make_unique<Formattable[]>(count);
+
+    Py_ssize_t pos = 0;
+    PyObject* key;
+    PyObject* value;
+    int32_t i = 0;
+    bool err = false;
+
+#ifdef Py_GIL_DISABLED
+    Py_BEGIN_CRITICAL_SECTION(dict);
+#endif
+    while (PyDict_Next(dict, &pos, &key, &value)) {
+        // Ensure we don't exceed allocated space
+        if (i >= count) {
+            PyErr_SetString(PyExc_RuntimeError, "Dictionary size changed during iteration");
+            err = true;
+            break;
+        }
+
+        if (key == nullptr) {
+            PyErr_SetString(PyExc_TypeError, "NULL key in dictionary");
+            err = true;
+            break;
+        }
+        if (value == nullptr) {
+            PyErr_SetString(PyExc_TypeError, "NULL value in dictionary");
+            err = true;
+            break;
+        }
+
+        Py_ssize_t key_size;
+        const char* key_str = PyUnicode_AsUTF8AndSize(key, &key_size);
+        if (key_str == nullptr) {
+            PyErr_SetString(PyExc_TypeError, "Dictionary keys must be strings");
+            err = true;
+            break;
+        }
+        names_ptr[i] = UnicodeString::fromUTF8(StringPiece(key_str, key_size));
+
+        if (!pyobject_to_formattable(value, values_ptr[i], mod_state)) {
+            if (!PyErr_Occurred()) {
+                PyErr_SetString(PyExc_TypeError, "Failed to convert dictionary value to Formattable");
+            }
+            err = true;
+            break;
+        }
+        ++i;
+    }
+#ifdef Py_GIL_DISABLED
+    Py_END_CRITICAL_SECTION();
+#endif
+    if (err) {
+        return false;
+    }
+
+    names = names_ptr.release();
+    values = values_ptr.release();
+    return true;
+}
+
+PyObject* MessageFormat_format(MessageFormatObject* self, PyObject* args) {
+    PyObject* params_dict;
+
+    if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &params_dict)) {
+        return nullptr;
+    }
+
+#if PY_VERSION_HEX < 0x030B0000
+    PyObject* module = _PyType_GetModuleByDef(Py_TYPE(self), &icu4pymodule);
+#else
+    PyObject* module = PyType_GetModuleByDef(Py_TYPE(self), &icu4pymodule);
+#endif
+    if (module == nullptr) {
+        return nullptr;
+    }
+    ModuleState* mod_state = get_module_state(module);
+
+    UnicodeString* argumentNames = nullptr;
+    Formattable* arguments = nullptr;
+    int32_t count = 0;
+
+    if (!dict_to_parallel_arrays(params_dict, mod_state, argumentNames, arguments, count)) {
+        return nullptr;
+    }
+
+    auto names_guard = std::unique_ptr<UnicodeString[]>(argumentNames);
+    auto values_guard = std::unique_ptr<Formattable[]>(arguments);
+
+    UErrorCode status = U_ZERO_ERROR;
+    UnicodeString result;
+
+    // ICU objects need external synchronization
+#ifdef Py_GIL_DISABLED
+    Py_BEGIN_CRITICAL_SECTION(self);
+#endif
+
+    if (count == 0) {
+        FieldPosition field_pos;
+        result = self->formatter->format(nullptr, 0, result, field_pos, status);
+    } else {
+        result = self->formatter->format(argumentNames, arguments, count, result, status);
+    }
+
+#ifdef Py_GIL_DISABLED
+    Py_END_CRITICAL_SECTION();
+#endif
+
+    if (U_FAILURE(status)) {
+        PyErr_Format(PyExc_RuntimeError, "Failed to format message: %s",
+                     u_errorName(status));
+        return nullptr;
+    }
+
+    std::string utf8;
+    result.toUTF8String(utf8);
+    return PyUnicode_FromStringAndSize(utf8.c_str(), utf8.size());
+}
+
+PyMethodDef MessageFormat_methods[] = {
+    {"format", reinterpret_cast<PyCFunction>(MessageFormat_format), METH_VARARGS,
+     "Format the message with given parameters"},
+    {nullptr, nullptr, 0, nullptr}
+};
+
+PyType_Slot MessageFormat_slots[] = {
+    {Py_tp_doc, const_cast<char*>("ICU MessageFormat")},
+    {Py_tp_dealloc, reinterpret_cast<void*>(MessageFormat_dealloc)},
+    {Py_tp_init, reinterpret_cast<void*>(MessageFormat_init)},
+    {Py_tp_new, reinterpret_cast<void*>(MessageFormat_new)},
+    {Py_tp_methods, MessageFormat_methods},
+    {0, nullptr}
+};
+
+PyType_Spec MessageFormat_spec = {
+    "icu4py.messageformat.MessageFormat",
+    sizeof(MessageFormatObject),
+    0,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+    MessageFormat_slots
+};
+
+int icu4py_messageformat_exec(PyObject* m) {
+    PyObject* type_obj = PyType_FromModuleAndSpec(m, &MessageFormat_spec, nullptr);
+    if (type_obj == nullptr) {
+        return -1;
+    }
+
+    if (PyModule_AddObject(m, "MessageFormat", type_obj) < 0) {
+        Py_DECREF(type_obj);
+        return -1;
+    }
+
+    ModuleState* state = get_module_state(m);
+
+    PyObject* datetime_module = PyImport_ImportModule("datetime");
+    if (datetime_module == nullptr) {
+        return -1;
+    }
+
+    state->datetime_datetime_type = PyObject_GetAttrString(datetime_module, "datetime");
+    state->datetime_date_type = PyObject_GetAttrString(datetime_module, "date");
+    state->datetime_time_type = PyObject_GetAttrString(datetime_module, "time");
+    Py_DECREF(datetime_module);
+
+    if (state->datetime_datetime_type == nullptr ||
+        state->datetime_date_type == nullptr ||
+        state->datetime_time_type == nullptr) {
+        return -1;
+    }
+
+    PyObject* decimal_module = PyImport_ImportModule("decimal");
+    if (decimal_module == nullptr) {
+        return -1;
+    }
+
+    state->decimal_decimal_type = PyObject_GetAttrString(decimal_module, "Decimal");
+    Py_DECREF(decimal_module);
+
+    if (state->decimal_decimal_type == nullptr) {
+        return -1;
+    }
+
+    PyObject* locale_module = PyImport_ImportModule("icu4py.locale");
+    if (locale_module == nullptr) {
+        return -1;
+    }
+
+    state->locale_type = PyObject_GetAttrString(locale_module, "Locale");
+    Py_DECREF(locale_module);
+
+    if (state->locale_type == nullptr) {
+        return -1;
+    }
+
+    return 0;
+}
+
+int icu4py_messageformat_traverse(PyObject* m, visitproc visit, void* arg) {
+    ModuleState* state = get_module_state(m);
+    Py_VISIT(state->datetime_datetime_type);
+    Py_VISIT(state->datetime_date_type);
+    Py_VISIT(state->datetime_time_type);
+    Py_VISIT(state->decimal_decimal_type);
+    Py_VISIT(state->locale_type);
+    return 0;
+}
+
+int icu4py_messageformat_clear(PyObject* m) {
+    ModuleState* state = get_module_state(m);
+    Py_CLEAR(state->datetime_datetime_type);
+    Py_CLEAR(state->datetime_date_type);
+    Py_CLEAR(state->datetime_time_type);
+    Py_CLEAR(state->decimal_decimal_type);
+    Py_CLEAR(state->locale_type);
+    return 0;
+}
+
+}  // anonymous namespace
+
+PyMODINIT_FUNC PyInit_messageformat() {
+    return PyModuleDef_Init(&icu4pymodule);
+}

icu4py/messageformat.pyi

@@ -0,0 +1,13 @@
+from datetime import date, datetime
+from decimal import Decimal
+
+from typing_extensions import disjoint_base
+
+from icu4py.locale import Locale
+
+@disjoint_base
+class MessageFormat:
+    def __init__(self, pattern: str, locale: str | Locale) -> None: ...
+    def format(
+        self, params: dict[str, int | float | str | Decimal | date | datetime]
+    ) -> str: ...

icu4py-0.2.0.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: icu4py
+Version: 0.2.0
+Summary: Bindings to the ICU (International Components for Unicode) library (ICU4C).
+Author-email: Adam Johnson <me@adamj.eu>
+License-Expression: MIT
+Project-URL: Changelog, https://icu4py.readthedocs.io/en/latest/changelog.html
+Project-URL: Documentation, https://icu4py.readthedocs.io/
+Project-URL: Funding, https://adamj.eu/books/
+Project-URL: Repository, https://github.com/adamchainz/icu4py
+Keywords: i18n,icu,icu4c,internationalization,l10n,localization,unicode
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: typing-extensions>=4.15
+Dynamic: license-file
+
+======
+icu4py
+======
+
+.. image:: https://img.shields.io/readthedocs/icu4py?style=for-the-badge
+   :target: https://icu4py.readthedocs.io/en/latest/
+
+.. image:: https://img.shields.io/github/actions/workflow/status/adamchainz/icu4py/main.yml.svg?branch=main&style=for-the-badge
+   :target: https://github.com/adamchainz/icu4py/actions?workflow=CI
+
+.. image:: https://img.shields.io/badge/Coverage-100%25-success?style=for-the-badge
+   :target: https://github.com/adamchainz/icu4py/actions?workflow=CI
+
+.. image:: https://img.shields.io/pypi/v/icu4py.svg?style=for-the-badge
+   :target: https://pypi.org/project/icu4py/
+
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge
+   :target: https://github.com/psf/black
+
+.. image:: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=for-the-badge
+   :target: https://github.com/pre-commit/pre-commit
+   :alt: pre-commit
+
+----
+
+Bindings to the ICU (International Components for Unicode) library (ICU4C).
+
+Documentation
+=============
+
+Please see https://icu4py.readthedocs.io/.

icu4py-0.2.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+icu4py/__init__.py,sha256=yd6ls9f_x8oeU3r7IckxKbisUmRm248CXOhAIYiUN1o,603
+icu4py/_version.cpp,sha256=idstiuGpfe-qXcv0tiAWOAUpSmDKsPzqB3sQDVu-cTc,1198
+icu4py/_version.cpython-314-i386-linux-gnu.so,sha256=11vmxJgF0-4dFXoyH3NwjB-DCuhQmOdkCQl18K8EZho,49905
+icu4py/_version.pyi,sha256=4Y8qCvpvU9n5aYm4a91lMh4KKoxe1zl-i-RD6mnAYiY,97
+icu4py/locale.cpp,sha256=Utkys6iRn2cyzySGEwtA3naXou59Bw5Yp5lpIr3rdYs,7522
+icu4py/locale.cpython-314-i386-linux-gnu.so,sha256=fOVUMia4XPRejprAzRpza-Y3fAKXq7Kj24sq3ipcjFc,120249
+icu4py/locale.pyi,sha256=em0XwMnghSxJzvYBbP-5Z9eei9SORkCMIJ95FciyyL8,618
+icu4py/messageformat.cpp,sha256=J8VDS81sDUdRooNao6pQjc2WPx91XuqO358QoVhwlzQ,16065
+icu4py/messageformat.cpython-314-i386-linux-gnu.so,sha256=meunm5SDHKHSUd99OTxglLVC54Ocp9e7FBEog6DwRNU,197377
+icu4py/messageformat.pyi,sha256=CXBlWn45WKsj9mJuPyCNifTKzqF56_taMgqpDhXrEkk,365
+icu4py/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+icu4py.libs/libicudata-6b8dd726.so.60.3,sha256=eE8crGu5rj1j2ahANkP8GExDiXXIls_j4Hw-tjB0kKM,26911137
+icu4py.libs/libicui18n-b2c40b87.so.60.3,sha256=xR30TLPf4pDZakai9iHJELFul28kCIXZ_48kv8cqqIY,4836529
+icu4py.libs/libicuuc-0090835d.so.60.3,sha256=3ktbP4bPVukKK0ZKvm5Qmpnuo0nnzuROfDDBzbtXP20,2775321
+icu4py-0.2.0.dist-info/METADATA,sha256=1Jc-hWpxxXk-8pAcWnC3irtwxHD-M_kDBEKByNFp5gE,2325
+icu4py-0.2.0.dist-info/WHEEL,sha256=CL7kcfXt3Qi0BlfapvDaMM5T4wH7ClmYaslWbc5vTcE,148
+icu4py-0.2.0.dist-info/top_level.txt,sha256=bT8eoOy2eVL3nNv2IXqQo-KpPtbBoR415Kow3HGtId8,7
+icu4py-0.2.0.dist-info/RECORD,,
+icu4py-0.2.0.dist-info/licenses/LICENSE,sha256=blVuFA7Qdp2_CcTyGXLxA4CsHsAjAquxVc4O6ODqye4,1069
+icu4py-0.2.0.dist-info/sboms/auditwheel.cdx.json,sha256=Pvus5d_wQ3covm3v7IhF6fs9Fc6dT8wDuywQJU6eYQo,2237

icu4py-0.2.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp314-cp314-manylinux_2_26_i686
+Tag: cp314-cp314-manylinux_2_28_i686
+

icu4py-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Adam Johnson
+
+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.

icu4py-0.2.0.dist-info/sboms/auditwheel.cdx.json

@@ -0,0 +1 @@
+{"bomFormat": "CycloneDX", "specVersion": "1.4", "version": 1, "metadata": {"component": {"type": "library", "bom-ref": "pkg:pypi/icu4py@0.2.0?file_name=icu4py-0.2.0-cp314-cp314-manylinux_2_26_i686.manylinux_2_28_i686.whl", "name": "icu4py", "version": "0.2.0", "purl": "pkg:pypi/icu4py@0.2.0?file_name=icu4py-0.2.0-cp314-cp314-manylinux_2_26_i686.manylinux_2_28_i686.whl"}, "tools": [{"name": "auditwheel", "version": "6.6.0"}]}, "components": [{"type": "library", "bom-ref": "pkg:pypi/icu4py@0.2.0?file_name=icu4py-0.2.0-cp314-cp314-manylinux_2_26_i686.manylinux_2_28_i686.whl", "name": "icu4py", "version": "0.2.0", "purl": "pkg:pypi/icu4py@0.2.0?file_name=icu4py-0.2.0-cp314-cp314-manylinux_2_26_i686.manylinux_2_28_i686.whl"}, {"type": "library", "bom-ref": "pkg:rpm/almalinux/libicu@60.3-2.el8_1#a4dd07e1764f749ca92700550e7aaf73d8e17b38cda7e4393fd076540922ca9b", "name": "libicu", "version": "60.3-2.el8_1", "purl": "pkg:rpm/almalinux/libicu@60.3-2.el8_1"}, {"type": "library", "bom-ref": "pkg:rpm/almalinux/libicu@60.3-2.el8_1#bc54d08b934be90f631e6b943c30a50fbf2f62c31d8ca683d163f18bb541b9c2", "name": "libicu", "version": "60.3-2.el8_1", "purl": "pkg:rpm/almalinux/libicu@60.3-2.el8_1"}, {"type": "library", "bom-ref": "pkg:rpm/almalinux/libicu@60.3-2.el8_1#c024d6fbcf17732e226533e2a8382a4432252af6288c495547593dba68b5d8e1", "name": "libicu", "version": "60.3-2.el8_1", "purl": "pkg:rpm/almalinux/libicu@60.3-2.el8_1"}], "dependencies": [{"ref": "pkg:pypi/icu4py@0.2.0?file_name=icu4py-0.2.0-cp314-cp314-manylinux_2_26_i686.manylinux_2_28_i686.whl", "dependsOn": ["pkg:rpm/almalinux/libicu@60.3-2.el8_1#a4dd07e1764f749ca92700550e7aaf73d8e17b38cda7e4393fd076540922ca9b", "pkg:rpm/almalinux/libicu@60.3-2.el8_1#bc54d08b934be90f631e6b943c30a50fbf2f62c31d8ca683d163f18bb541b9c2", "pkg:rpm/almalinux/libicu@60.3-2.el8_1#c024d6fbcf17732e226533e2a8382a4432252af6288c495547593dba68b5d8e1"]}, {"ref": "pkg:rpm/almalinux/libicu@60.3-2.el8_1#a4dd07e1764f749ca92700550e7aaf73d8e17b38cda7e4393fd076540922ca9b"}, {"ref": "pkg:rpm/almalinux/libicu@60.3-2.el8_1#bc54d08b934be90f631e6b943c30a50fbf2f62c31d8ca683d163f18bb541b9c2"}, {"ref": "pkg:rpm/almalinux/libicu@60.3-2.el8_1#c024d6fbcf17732e226533e2a8382a4432252af6288c495547593dba68b5d8e1"}]}

icu4py-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+icu4py