| Name | PyICU JSON |
| Version |
2.14
JSON |
| download |
| home_page | https://gitlab.pyicu.org/main/pyicu |
| Summary | Python extension wrapping the ICU C++ API |
| upload_time | 2024-10-26 08:46:03 |
| maintainer | None |
| docs_url | None |
| author | Andi Vajda |
| requires_python | None |
| license | MIT |
| keywords |
|
| VCS |
|
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# README file for PyICU
## Welcome
Welcome to PyICU, a Python extension wrapping the ICU C++ libraries.
ICU stands for "International Components for Unicode".
These are the i18n libraries of the Unicode Consortium.
They implement much of the Unicode Standard,
many of its companion Unicode Technical Standards,
and much of Unicode CLDR.
The PyICU source code is hosted at https://gitlab.pyicu.org/main/pyicu.
The ICU homepage is https://icu.unicode.org/
See also the CLDR homepage at http://cldr.unicode.org/
## Installing PyICU
PyICU is a python extension implemented in C++ that wraps the C/C++ ICU library.
It is known to also work as a [PyPy](https://www.pypy.org/) extension.
Unless ``pkg-config`` and the ICU libraries and headers are already installed,
building PyICU from the sources on [PyPI](https://pypi.org/project/PyICU/)
involves more than just a ``pip`` call. Many operating systems distribute
pre-built binary packages of ICU and PyICU, see below.
- Mac OS X
- Ensure ICU is installed and can be found by `pkg-config` (as `icu-config` was [deprecated](https://unicode-org.github.io/icu/userguide/icu/howtouseicu.html#c-makefiles) as of ICU 63.1), either by following [ICU build instructions](https://unicode-org.github.io/icu/userguide/icu4c/build.html), or by using Homebrew:
```sh
# install libicu (keg-only)
brew install pkg-config icu4c
# let setup.py discover keg-only icu4c via pkg-config
export PATH="/usr/local/opt/icu4c/bin:/usr/local/opt/icu4c/sbin:$PATH"
export PKG_CONFIG_PATH="$PKG_CONFIG_PATH:/usr/local/opt/icu4c/lib/pkgconfig"
```
- Install PyICU **with the same C++ compiler as your Python distribution**
([more info](https://gitlab.pyicu.org/main/pyicu/merge_requests/140#issuecomment-782283491)):
```sh
# EITHER - when using a gcc-built CPython (e.g. from Homebrew)
export CC="$(which gcc)" CXX="$(which g++)"
# OR - when using system CPython or another clang-based CPython, ensure system clang is used (for proper libstdc++ https://gitlab.pyicu.org/main/pyicu/issues/5#issuecomment-291631507):
unset CC CXX
# avoid wheels from previous runs or PyPI
pip install --no-binary=:pyicu: pyicu
```
- ICU and PyICU binaries are both available via [Macports](https://www.macports.org/) as well. The same limitations about mixing binaries may apply.
```sh
# see versions available
/opt/local/bin/port search pyicu
sudo /opt/local/bin/port install ...
```
- Debian
```sh
apt-get update
# EITHER - from apt directly https://packages.debian.org/source/stable/pyicu
apt-get install python3-icu
# OR - from source
apt-get install pkg-config libicu-dev
pip install --no-binary=:pyicu: pyicu
```
- Ubuntu: similar to Debian, there is a pyicu
[package](https://packages.ubuntu.com/source/noble/python/pyicu)
available via ``apt``.
- Alpine Linux: there is a pyicu
[package](https://pkgs.alpinelinux.org/package/edge/community/x86/py3-icu)
available via ``apk``.
- NetBSD: there is a pyicu [package](https://pkgsrc.se/textproc/py-ICU)
available via ``pkg_add``.
- OpenBSD: there is a pyicu [package](https://openports.se/textproc/py-ICU)
available via ``pkg_add``.
- Other operating systems: see below.
## Building PyICU
*Please, refer to [next section](#building-pyicu-python-3-and-icu-from-sources) for building Python, ICU and PyICU from sources.
The current section is about building only PyICU from sources, with all dependencies such as Python and ICU already present.*
Before building PyICU the ICU libraries must be built and installed. Refer
to each system's [instructions](https://unicode-org.github.io/icu/userguide/icu4c/build.html) for more information.
PyICU is built from sources with ``setuptools`` or with ``build`` and ``pip``:
- verify that ``pkg-config`` is available (the ``icu-config`` program is
[deprecated](https://unicode-org.github.io/icu/userguide/icu/howtouseicu.html#c-makefiles)
as of ICU 63.1)
```sh
pkg-config --cflags --libs icu-i18n
```
If this command returns an error or doesn't return the paths expected
then ensure that the ``INCLUDES``, ``LFLAGS``, ``CFLAGS`` and ``LIBRARIES``
dictionaries in ``setup.py`` contain correct values for your platform.
With ICU versions [60, 74] ``-std=c++11`` must appear in your CFLAGS or
be the default for your C++ compiler. Starting with ICU 75 ``-std=c++17``
must appear in your CFLAGS or be the default for your C++ compiler.
- **either** build and install PyICU with ``setuptools``
```sh
python setup.py build
sudo python setup.py install
```
- **or** build PyICU with ``build`` and install it with ``pip``
```sh
python -m build
sudo python -m pip install dist/PyICU-<version>-<platform>.whl
```
- **either** test PyICU with ``setuptools``
```sh
python setup.py test
```
- **or** test PyICU with ``pytest``
```sh
python -m pytest
```
## Building PyICU, Python 3 and ICU from sources
The instructions at [note_855](https://gitlab.pyicu.org/main/pyicu/-/issues/153#note_855) contain the complete steps for building everything from sources into
a self-contained directory, without modifying any system directories. They were
made and tested on an M1 Mac but they can be modified and reused for any unix
environment. In particular, they outline how to build PyICU from sources
without icu-config or pkg-config being present.
## Running PyICU
- Mac OS X
Make sure that ``DYLD_LIBRARY_PATH`` contains paths to the directory(ies)
containing the ICU libs.
- Linux & Solaris
Make sure that ``LD_LIBRARY_PATH`` contains paths to the directory(ies)
containing the ICU libs or that you added the corresponding ``-rpath``
argument to ``LFLAGS``.
- Windows
Make sure that ``PATH`` contains paths to the directory(ies)
containing the ICU DLLs.
## What's available
See the [CHANGES](https://gitlab.pyicu.org/main/pyicu/blob/main/CHANGES) file
for an up to date log of changes and additions.
## API Documentation
There is no API documentation for PyICU. The API for ICU is documented at
https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/ and the
following patterns can be used to translate from the C++ APIs to the
corresponding Python APIs.
### strings
The ICU string type, [UnicodeString](https://unicode-org.github.io/icu-docs/apidoc/dev/icu4c/classicu_1_1UnicodeString.html), is a type pointing at a mutable array of [UChar](https://unicode-org.github.io/icu-docs/apidoc/dev/icu4c/umachine_8h.html#a6bb9fad572d65b305324ef288165e2ac) Unicode 16-bit wide characters and is described [here](https://unicode-org.github.io/icu-docs/apidoc/dev/icu4c/classicu_1_1UnicodeString.html#details). The Python 3 [str](https://docs.python.org/3/library/stdtypes.html#str) type is described [here](https://docs.python.org/3/library/stdtypes.html#index-26) and [here](https://docs.python.org/3/howto/unicode.html). The Python 2 [unicode](https://docs.python.org/2.7/reference/datamodel.html#index-23) type is described [here](https://docs.python.org/2.7/library/stdtypes.html#sequence-types-str-unicode-list-tuple-bytearray-buffer-xrange).
Because of their differences, ICU's and Python's string objects are not merged
into the same type when crossing the C++ boundary but converted.
ICU APIs taking ``UnicodeString`` arguments have been overloaded to also
accept arguments that are Python 3 ``str`` or Python 2 ``unicode`` objects.
Python 2 ``str`` objects are auto-decoded into ICU strings using the ``utf-8``
encoding.
To convert a Python 3 ``bytes`` or a Python 2 ``str`` object encoded in an
encoding other than ``utf-8`` to an ICU ``UnicodeString`` use the
``UnicodeString(str, encodingName)`` constructor.
ICU's C++ APIs accept and return ``UnicodeString`` arguments in several
ways: by value, by pointer or by reference.
When an ICU C++ API is documented to accept a ``UnicodeString`` reference
parameter, it is safe to assume that there are several corresponding
PyICU python APIs making it accessible in simpler ways:
For example, the ``'UnicodeString &Locale::getDisplayName(UnicodeString &)'``
API, documented
[here](https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1Locale.html#a61def321a9cfd9904b59e3f1897f835e),
can be invoked from Python in several ways:
1. The ICU way
>>> from icu import UnicodeString, Locale
>>> locale = Locale('pt_BR')
>>> string = UnicodeString()
>>> name = locale.getDisplayName(string)
>>> name
<UnicodeString: 'Portuguese (Brazil)'>
>>> name is string
True <-- string arg was returned, modified in place
2. The Python way
>>> from icu import Locale
>>> locale = Locale('pt_BR')
>>> name = locale.getDisplayName()
>>> name
'Portuguese (Brazil)'
A ``UnicodeString`` object was allocated and converted to a Python
``str`` object.
A UnicodeString can be converted to a Python unicode string with Python 3's
``str()`` or Python 2's ``unicode()`` constructor. The usual ``len()``,
comparison, `[]`` and ``[:]`` operators are all available, with the additional
twists that slicing is not read-only and that ``+=`` is also available since a
UnicodeString is mutable. For example:
>>> name = locale.getDisplayName()
'Portuguese (Brazil)'
>>> name = UnicodeString(name)
>>> name
<UnicodeString: 'Portuguese (Brazil)'>
>>> str(name)
'Portuguese (Brazil)'
>>> len(name)
19
>>> str(name)
'Portuguese (Brazil)'
>>> name[3]
't'
>>> name[12:18]
<UnicodeString: 'Brazil'>
>>> name[12:18] = 'the country of Brasil'
>>> name
<UnicodeString: 'Portuguese (the country of Brasil)'>
>>> name += ' oh joy'
>>> name
<UnicodeString: 'Portuguese (the country of Brasil) oh joy'>
### error reporting
The C++ ICU library does not use C++ exceptions to report errors. ICU
C++ APIs return errors via a ``UErrorCode`` reference argument. All such
APIs are wrapped by Python APIs that omit this argument and throw an
``ICUError`` Python exception instead. The same is true for ICU APIs
taking both a ``ParseError`` and a ``UErrorCode``, they are both to be
omitted.
For example, the ``'UnicodeString &DateFormat::format(const Formattable &, UnicodeString &, FieldPosition &, UErrorCode &)'`` API, documented [here](https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1DateFormat.html#aae63209f1202550c91e2beed5691b062) is invoked from Python with:
>>> from icu import DateFormat, Formattable
>>> df = DateFormat.createInstance()
>>> df
<SimpleDateFormat: M/d/yy h:mm a>
>>> f = Formattable(940284258.0, Formattable.kIsDate)
>>> df.format(f)
'10/18/99 3:04 PM'
Of course, the simpler ``'UnicodeString &DateFormat::format(UDate, UnicodeString &)'`` documented [here](https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1DateFormat.html#a5940ccf5676d3fa043d8255c55b7ddd1) can be used too:
>>> from icu import DateFormat
>>> df = DateFormat.createInstance()
>>> df
<SimpleDateFormat: M/d/yy h:mm a>
>>> df.format(940284258.0)
'10/18/99 3:04 PM'
### dates
ICU uses a double floating point type called ``UDate`` that represents the
number of milliseconds elapsed since 1970-jan-01 UTC for dates.
In Python, the value returned by the ``time`` module's ``time()``
function is the number of seconds since 1970-jan-01 UTC. Because of this
difference, floating point values are multiplied by 1000 when passed to
APIs taking ``UDate`` and divided by 1000 when returned as ``UDate``.
Python's ``datetime`` objects, with or without timezone information, can
also be used with APIs taking ``UDate`` arguments. The ``datetime``
objects get converted to ``UDate`` when crossing into the C++ layer.
### arrays
Many ICU API take array arguments. A list of elements of the array
element types is to be passed from Python.
### StringEnumeration
An ICU ``StringEnumeration`` has three ``next`` methods: ``next()`` which
returns ``str`` objects, ``unext()`` which returns ``str`` objects in Python 3
or ``unicode`` objects in Python 2 and ``snext()`` which returns
``UnicodeString`` objects. Any of these methods can be used as an iterator,
using the Python built-in ``iter`` function.
For example, let ``e`` be a ``StringEnumeration`` instance:
```python
e = TimeZone.createEnumeration()
[s for s in e] # a list of 'str' objects
[s for s in iter(e.unext, '')] # a list of 'str' or 'unicode' objects
[s for s in iter(e.snext, '')] # a list of 'UnicodeString' objects
```
### timezones
The ICU ``TimeZone`` type may be wrapped with an ``ICUtzinfo`` type for
usage with Python's ``datetime`` type. For example:
```python
from datetime import datetime
tz = ICUtzinfo(TimeZone.createTimeZone('US/Mountain'))
datetime.now(tz)
```
or, even simpler:
```python
tz = ICUtzinfo.getInstance('Pacific/Fiji')
datetime.now(tz)
```
To get the default time zone use:
```python
defaultTZ = ICUtzinfo.getDefault()
```
To get the time zone's id, use the ``tzid`` attribute or coerce the time
zone to a string:
```python
ICUtzinfo.getInstance('Pacific/Fiji').tzid -> 'Pacific/Fiji'
str(ICUtzinfo.getInstance('Pacific/Fiji')) -> 'Pacific/Fiji'
```
## Further Reading
The [unit tests](https://gitlab.pyicu.org/main/pyicu/-/tree/main/test) have
more examples of actual PyICU usage.
There are also a few
[samples](https://gitlab.pyicu.org/main/pyicu/-/tree/main/samples) ported from
ICU C/C++.
Last but not least, this [cheat sheet](https://gist.github.com/dpk/8325992) has useful examples.
Raw data
{
"_id": null,
"home_page": "https://gitlab.pyicu.org/main/pyicu",
"name": "PyICU",
"maintainer": null,
"docs_url": null,
"requires_python": null,
"maintainer_email": null,
"keywords": null,
"author": "Andi Vajda",
"author_email": "vajda@pyicu.org",
"download_url": "https://files.pythonhosted.org/packages/52/21/4e9b0a3ace3027fc63107fa2b5d6e66e321e104da071d787856962fbad52/PyICU-2.14.tar.gz",
"platform": null,
"description": "# README file for PyICU\n\n## Welcome\n\nWelcome to PyICU, a Python extension wrapping the ICU C++ libraries.\n\nICU stands for \"International Components for Unicode\".\nThese are the i18n libraries of the Unicode Consortium.\nThey implement much of the Unicode Standard,\nmany of its companion Unicode Technical Standards,\nand much of Unicode CLDR.\n\nThe PyICU source code is hosted at https://gitlab.pyicu.org/main/pyicu.\n\nThe ICU homepage is https://icu.unicode.org/\n\nSee also the CLDR homepage at http://cldr.unicode.org/\n\n## Installing PyICU\n\nPyICU is a python extension implemented in C++ that wraps the C/C++ ICU library.\nIt is known to also work as a [PyPy](https://www.pypy.org/) extension.\nUnless ``pkg-config`` and the ICU libraries and headers are already installed,\nbuilding PyICU from the sources on [PyPI](https://pypi.org/project/PyICU/)\ninvolves more than just a ``pip`` call. Many operating systems distribute\npre-built binary packages of ICU and PyICU, see below.\n\n - Mac OS X\n - Ensure ICU is installed and can be found by `pkg-config` (as `icu-config` was [deprecated](https://unicode-org.github.io/icu/userguide/icu/howtouseicu.html#c-makefiles) as of ICU 63.1), either by following [ICU build instructions](https://unicode-org.github.io/icu/userguide/icu4c/build.html), or by using Homebrew:\n ```sh\n # install libicu (keg-only)\n brew install pkg-config icu4c\n\n # let setup.py discover keg-only icu4c via pkg-config\n export PATH=\"/usr/local/opt/icu4c/bin:/usr/local/opt/icu4c/sbin:$PATH\"\n export PKG_CONFIG_PATH=\"$PKG_CONFIG_PATH:/usr/local/opt/icu4c/lib/pkgconfig\"\n ```\n - Install PyICU **with the same C++ compiler as your Python distribution**\n ([more info](https://gitlab.pyicu.org/main/pyicu/merge_requests/140#issuecomment-782283491)):\n ```sh\n # EITHER - when using a gcc-built CPython (e.g. from Homebrew)\n export CC=\"$(which gcc)\" CXX=\"$(which g++)\"\n # OR - when using system CPython or another clang-based CPython, ensure system clang is used (for proper libstdc++ https://gitlab.pyicu.org/main/pyicu/issues/5#issuecomment-291631507):\n unset CC CXX\n\n # avoid wheels from previous runs or PyPI\n pip install --no-binary=:pyicu: pyicu\n ```\n\n - ICU and PyICU binaries are both available via [Macports](https://www.macports.org/) as well. The same limitations about mixing binaries may apply.\n ```sh\n # see versions available\n /opt/local/bin/port search pyicu\n sudo /opt/local/bin/port install ...\n ```\n\n - Debian\n ```sh\n apt-get update\n \n # EITHER - from apt directly https://packages.debian.org/source/stable/pyicu\n apt-get install python3-icu\n # OR - from source\n apt-get install pkg-config libicu-dev\n pip install --no-binary=:pyicu: pyicu\n ```\n\n - Ubuntu: similar to Debian, there is a pyicu\n [package](https://packages.ubuntu.com/source/noble/python/pyicu)\n available via ``apt``.\n\n - Alpine Linux: there is a pyicu\n [package](https://pkgs.alpinelinux.org/package/edge/community/x86/py3-icu)\n available via ``apk``.\n\n - NetBSD: there is a pyicu [package](https://pkgsrc.se/textproc/py-ICU)\n available via ``pkg_add``.\n\n - OpenBSD: there is a pyicu [package](https://openports.se/textproc/py-ICU)\n available via ``pkg_add``.\n\n - Other operating systems: see below.\n\n## Building PyICU\n\n*Please, refer to [next section](#building-pyicu-python-3-and-icu-from-sources) for building Python, ICU and PyICU from sources.\nThe current section is about building only PyICU from sources, with all dependencies such as Python and ICU already present.*\n\nBefore building PyICU the ICU libraries must be built and installed. Refer\nto each system's [instructions](https://unicode-org.github.io/icu/userguide/icu4c/build.html) for more information.\n\nPyICU is built from sources with ``setuptools`` or with ``build`` and ``pip``:\n\n - verify that ``pkg-config`` is available (the ``icu-config`` program is\n [deprecated](https://unicode-org.github.io/icu/userguide/icu/howtouseicu.html#c-makefiles)\n as of ICU 63.1)\n ```sh\n pkg-config --cflags --libs icu-i18n\n ```\n If this command returns an error or doesn't return the paths expected\n then ensure that the ``INCLUDES``, ``LFLAGS``, ``CFLAGS`` and ``LIBRARIES``\n dictionaries in ``setup.py`` contain correct values for your platform.\n With ICU versions [60, 74] ``-std=c++11`` must appear in your CFLAGS or\n be the default for your C++ compiler. Starting with ICU 75 ``-std=c++17``\n must appear in your CFLAGS or be the default for your C++ compiler.\n\n - **either** build and install PyICU with ``setuptools``\n ```sh\n python setup.py build\n sudo python setup.py install\n ```\n\n - **or** build PyICU with ``build`` and install it with ``pip``\n ```sh\n python -m build\n sudo python -m pip install dist/PyICU-<version>-<platform>.whl\n ```\n\n - **either** test PyICU with ``setuptools``\n ```sh\n python setup.py test\n ```\n\n - **or** test PyICU with ``pytest``\n ```sh\n python -m pytest\n ```\n\n\n## Building PyICU, Python 3 and ICU from sources\n\nThe instructions at [note_855](https://gitlab.pyicu.org/main/pyicu/-/issues/153#note_855) contain the complete steps for building everything from sources into\na self-contained directory, without modifying any system directories. They were\nmade and tested on an M1 Mac but they can be modified and reused for any unix\nenvironment. In particular, they outline how to build PyICU from sources\nwithout icu-config or pkg-config being present.\n\n\n## Running PyICU\n\n - Mac OS X\n Make sure that ``DYLD_LIBRARY_PATH`` contains paths to the directory(ies)\n containing the ICU libs.\n\n - Linux & Solaris\n Make sure that ``LD_LIBRARY_PATH`` contains paths to the directory(ies)\n containing the ICU libs or that you added the corresponding ``-rpath``\n argument to ``LFLAGS``.\n\n - Windows\n Make sure that ``PATH`` contains paths to the directory(ies)\n containing the ICU DLLs.\n\n\n## What's available\n\nSee the [CHANGES](https://gitlab.pyicu.org/main/pyicu/blob/main/CHANGES) file\nfor an up to date log of changes and additions.\n\n\n## API Documentation\n\nThere is no API documentation for PyICU. The API for ICU is documented at\nhttps://unicode-org.github.io/icu-docs/apidoc/released/icu4c/ and the\nfollowing patterns can be used to translate from the C++ APIs to the\ncorresponding Python APIs.\n\n### strings\n\nThe ICU string type, [UnicodeString](https://unicode-org.github.io/icu-docs/apidoc/dev/icu4c/classicu_1_1UnicodeString.html), is a type pointing at a mutable array of [UChar](https://unicode-org.github.io/icu-docs/apidoc/dev/icu4c/umachine_8h.html#a6bb9fad572d65b305324ef288165e2ac) Unicode 16-bit wide characters and is described [here](https://unicode-org.github.io/icu-docs/apidoc/dev/icu4c/classicu_1_1UnicodeString.html#details). The Python 3 [str](https://docs.python.org/3/library/stdtypes.html#str) type is described [here](https://docs.python.org/3/library/stdtypes.html#index-26) and [here](https://docs.python.org/3/howto/unicode.html). The Python 2 [unicode](https://docs.python.org/2.7/reference/datamodel.html#index-23) type is described [here](https://docs.python.org/2.7/library/stdtypes.html#sequence-types-str-unicode-list-tuple-bytearray-buffer-xrange).\n\nBecause of their differences, ICU's and Python's string objects are not merged\ninto the same type when crossing the C++ boundary but converted.\n\nICU APIs taking ``UnicodeString`` arguments have been overloaded to also\naccept arguments that are Python 3 ``str`` or Python 2 ``unicode`` objects.\nPython 2 ``str`` objects are auto-decoded into ICU strings using the ``utf-8``\nencoding.\n\nTo convert a Python 3 ``bytes`` or a Python 2 ``str`` object encoded in an\nencoding other than ``utf-8`` to an ICU ``UnicodeString`` use the\n``UnicodeString(str, encodingName)`` constructor.\n\nICU's C++ APIs accept and return ``UnicodeString`` arguments in several\nways: by value, by pointer or by reference.\nWhen an ICU C++ API is documented to accept a ``UnicodeString`` reference\nparameter, it is safe to assume that there are several corresponding\nPyICU python APIs making it accessible in simpler ways:\n\nFor example, the ``'UnicodeString &Locale::getDisplayName(UnicodeString &)'``\nAPI, documented\n[here](https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1Locale.html#a61def321a9cfd9904b59e3f1897f835e),\ncan be invoked from Python in several ways:\n\n1. The ICU way\n\n >>> from icu import UnicodeString, Locale\n >>> locale = Locale('pt_BR')\n >>> string = UnicodeString()\n >>> name = locale.getDisplayName(string)\n >>> name\n <UnicodeString: 'Portuguese (Brazil)'>\n >>> name is string\n True <-- string arg was returned, modified in place\n\n2. The Python way\n\n >>> from icu import Locale\n >>> locale = Locale('pt_BR')\n >>> name = locale.getDisplayName()\n >>> name\n 'Portuguese (Brazil)'\n\n A ``UnicodeString`` object was allocated and converted to a Python\n ``str`` object.\n\nA UnicodeString can be converted to a Python unicode string with Python 3's\n``str()`` or Python 2's ``unicode()`` constructor. The usual ``len()``,\ncomparison, `[]`` and ``[:]`` operators are all available, with the additional\ntwists that slicing is not read-only and that ``+=`` is also available since a\nUnicodeString is mutable. For example:\n\n >>> name = locale.getDisplayName()\n 'Portuguese (Brazil)'\n >>> name = UnicodeString(name)\n >>> name\n <UnicodeString: 'Portuguese (Brazil)'>\n >>> str(name)\n 'Portuguese (Brazil)'\n >>> len(name)\n 19\n >>> str(name)\n 'Portuguese (Brazil)'\n >>> name[3]\n 't'\n >>> name[12:18]\n <UnicodeString: 'Brazil'>\n >>> name[12:18] = 'the country of Brasil'\n >>> name\n <UnicodeString: 'Portuguese (the country of Brasil)'>\n >>> name += ' oh joy'\n >>> name\n <UnicodeString: 'Portuguese (the country of Brasil) oh joy'>\n\n### error reporting\n\nThe C++ ICU library does not use C++ exceptions to report errors. ICU\nC++ APIs return errors via a ``UErrorCode`` reference argument. All such\nAPIs are wrapped by Python APIs that omit this argument and throw an\n``ICUError`` Python exception instead. The same is true for ICU APIs\ntaking both a ``ParseError`` and a ``UErrorCode``, they are both to be\nomitted.\n\nFor example, the ``'UnicodeString &DateFormat::format(const Formattable &, UnicodeString &, FieldPosition &, UErrorCode &)'`` API, documented [here](https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1DateFormat.html#aae63209f1202550c91e2beed5691b062) is invoked from Python with:\n\n >>> from icu import DateFormat, Formattable\n >>> df = DateFormat.createInstance()\n >>> df\n <SimpleDateFormat: M/d/yy h:mm a>\n >>> f = Formattable(940284258.0, Formattable.kIsDate)\n >>> df.format(f)\n '10/18/99 3:04 PM'\n\nOf course, the simpler ``'UnicodeString &DateFormat::format(UDate, UnicodeString &)'`` documented [here](https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1DateFormat.html#a5940ccf5676d3fa043d8255c55b7ddd1) can be used too:\n\n >>> from icu import DateFormat\n >>> df = DateFormat.createInstance()\n >>> df\n <SimpleDateFormat: M/d/yy h:mm a>\n >>> df.format(940284258.0)\n '10/18/99 3:04 PM'\n\n### dates\n\nICU uses a double floating point type called ``UDate`` that represents the\nnumber of milliseconds elapsed since 1970-jan-01 UTC for dates.\n\nIn Python, the value returned by the ``time`` module's ``time()``\nfunction is the number of seconds since 1970-jan-01 UTC. Because of this\ndifference, floating point values are multiplied by 1000 when passed to\nAPIs taking ``UDate`` and divided by 1000 when returned as ``UDate``.\n\nPython's ``datetime`` objects, with or without timezone information, can\nalso be used with APIs taking ``UDate`` arguments. The ``datetime``\nobjects get converted to ``UDate`` when crossing into the C++ layer.\n\n### arrays\n\nMany ICU API take array arguments. A list of elements of the array\nelement types is to be passed from Python.\n\n### StringEnumeration\n\nAn ICU ``StringEnumeration`` has three ``next`` methods: ``next()`` which\nreturns ``str`` objects, ``unext()`` which returns ``str`` objects in Python 3\nor ``unicode`` objects in Python 2 and ``snext()`` which returns\n``UnicodeString`` objects. Any of these methods can be used as an iterator,\nusing the Python built-in ``iter`` function.\n\nFor example, let ``e`` be a ``StringEnumeration`` instance:\n\n```python\ne = TimeZone.createEnumeration()\n[s for s in e] # a list of 'str' objects\n[s for s in iter(e.unext, '')] # a list of 'str' or 'unicode' objects\n[s for s in iter(e.snext, '')] # a list of 'UnicodeString' objects\n```\n\n### timezones\n\nThe ICU ``TimeZone`` type may be wrapped with an ``ICUtzinfo`` type for\nusage with Python's ``datetime`` type. For example:\n\n```python\nfrom datetime import datetime\ntz = ICUtzinfo(TimeZone.createTimeZone('US/Mountain'))\ndatetime.now(tz)\n```\n\nor, even simpler:\n\n```python\ntz = ICUtzinfo.getInstance('Pacific/Fiji')\ndatetime.now(tz)\n```\n\nTo get the default time zone use:\n\n```python\ndefaultTZ = ICUtzinfo.getDefault()\n```\n\nTo get the time zone's id, use the ``tzid`` attribute or coerce the time\nzone to a string:\n\n```python\nICUtzinfo.getInstance('Pacific/Fiji').tzid -> 'Pacific/Fiji'\nstr(ICUtzinfo.getInstance('Pacific/Fiji')) -> 'Pacific/Fiji'\n```\n\n## Further Reading\n\nThe [unit tests](https://gitlab.pyicu.org/main/pyicu/-/tree/main/test) have\nmore examples of actual PyICU usage.\n\nThere are also a few\n[samples](https://gitlab.pyicu.org/main/pyicu/-/tree/main/samples) ported from\nICU C/C++.\n\nLast but not least, this [cheat sheet](https://gist.github.com/dpk/8325992) has useful examples.\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "Python extension wrapping the ICU C++ API",
"version": "2.14",
"project_urls": {
"Homepage": "https://gitlab.pyicu.org/main/pyicu"
},
"split_keywords": [],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "52214e9b0a3ace3027fc63107fa2b5d6e66e321e104da071d787856962fbad52",
"md5": "7ec5ad0d62a2a27f919ca8a775352a71",
"sha256": "acc7eb92bd5c554ed577249c6978450a4feda0aa6f01470152b3a7b382a02132"
},
"downloads": -1,
"filename": "PyICU-2.14.tar.gz",
"has_sig": false,
"md5_digest": "7ec5ad0d62a2a27f919ca8a775352a71",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 263912,
"upload_time": "2024-10-26T08:46:03",
"upload_time_iso_8601": "2024-10-26T08:46:03.489007Z",
"url": "https://files.pythonhosted.org/packages/52/21/4e9b0a3ace3027fc63107fa2b5d6e66e321e104da071d787856962fbad52/PyICU-2.14.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-10-26 08:46:03",
"github": false,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"lcname": "pyicu"
}
