python-intl 0.1.0__tar.gz → 0.3.1__tar.gz

python_intl-0.3.1/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: python-intl
+Version: 0.3.1
+Summary: Python implementation of the Intl JavaScript API
+Author: David Danier
+Author-email: David Danier <david.danier@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: pyicu>=2.16.2
+Requires-Python: >=3.12
+Project-URL: Repository, https://github.com/ddanier/python-intl
+Description-Content-Type: text/markdown
+
+# `python-intl`
+
+A small library using [PyICU](https://pypi.org/project/pyicu/) to provide a Python 
+API similar to what the [`Intl` JavaScript API](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl)
+provides. It is not meant to fully behave the same, but instead be close enough so
+the "same" code works on JavaScript and Python, with similar results.
+
+**Status:** This is very much work in progress. Currently only `Intl.DateTimeFormat`
+exists and this also is not complete yet.
+
+## General notes about the Python adaption
+
+All names will be using the Python style rules. This means instead of 
+`formatToParts` a method will be called `format_to_parts`. Also a dictionary
+key like `dayPeriod` will be named `day_period`. Python uses snake case, let's
+stick to this.
+
+Instead of passing around undefined objects like in JavaScript we want to use
+well defined and typed dataclasses. This for example is true for the
+`Intl.DateTimeFormat` format options, you can use `DateTimeFormatOptions` as
+a clean representation of those. Using a dictionary (which behaves the most
+like those JavaScript objects) is still fine and will automatically converted,
+as seen in the examples here.
+
+Many objects like for example the `DateTimeFormatOptions` provide methods to
+convert their Python representation to a JavaScript compatible JSON format
+by returning a `dict` using the JavaScript naming. You can use the `to_json`
+method for this.
+
+For example:
+```python
+import python_intl as Intl
+
+Intl.DateTimeFormatOptions(time_zone_name="short_offset").to_json()
+# Will return: {'timeZoneName': 'shortOffset'}
+```
+
+## Available `Intl` classes
+
+### `Intl.DateTimeFormat`
+
+#### Example usage
+
+```python
+import datetime
+import python_intl as Intl
+
+datetime_ = datetime.datetime(2026, 8, 15)
+formatter = Intl.DateTimeFormat("de-DE", {"year": "numeric", "month": "2-digit", "day": "2-digit"})
+formatter.format(datetime_)  # Will output the German format: "15.08.2026"
+```
+
+#### Compatibility
+
+| Method                              | Status | Python name                      |
+| ----------------------------------- | :----: | -------------------------------- |
+| `DateTimeFormat.format`             | ✅     |                                  |
+| `DateTimeFormat.formatToParts`      | ✅     | `DateTimeFormat.format_to_parts` |
+| `DateTimeFormat.supportedLocalesOf` | ❌     |                                  |
+| `DateTimeFormat.formatRange`        | ❌     |                                  |
+| `DateTimeFormat.formatRangeToParts` | ❌     |                                  |
+| `DateTimeFormat.resolvedOptions`    | ❌     |                                  |
+
+## Installation
+
+Be sure to be able to install `PyICU`, see the installation docs there:
+https://gitlab.pyicu.org/main/pyicu#installing-pyicu
+
+**Hint:** I mainly did run into issues with `pkg-config` not finding the ICU library,
+setting `PKG_CONFIG_PATH` accordingly helps most of the time I guess.
+
+When this is done you should be able to install `python-intl` using any package
+manager, like `pip install python-intl` or `uv add python-intl`.

python_intl-0.3.1/README.md

@@ -0,0 +1,73 @@
+# `python-intl`
+
+A small library using [PyICU](https://pypi.org/project/pyicu/) to provide a Python 
+API similar to what the [`Intl` JavaScript API](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl)
+provides. It is not meant to fully behave the same, but instead be close enough so
+the "same" code works on JavaScript and Python, with similar results.
+
+**Status:** This is very much work in progress. Currently only `Intl.DateTimeFormat`
+exists and this also is not complete yet.
+
+## General notes about the Python adaption
+
+All names will be using the Python style rules. This means instead of 
+`formatToParts` a method will be called `format_to_parts`. Also a dictionary
+key like `dayPeriod` will be named `day_period`. Python uses snake case, let's
+stick to this.
+
+Instead of passing around undefined objects like in JavaScript we want to use
+well defined and typed dataclasses. This for example is true for the
+`Intl.DateTimeFormat` format options, you can use `DateTimeFormatOptions` as
+a clean representation of those. Using a dictionary (which behaves the most
+like those JavaScript objects) is still fine and will automatically converted,
+as seen in the examples here.
+
+Many objects like for example the `DateTimeFormatOptions` provide methods to
+convert their Python representation to a JavaScript compatible JSON format
+by returning a `dict` using the JavaScript naming. You can use the `to_json`
+method for this.
+
+For example:
+```python
+import python_intl as Intl
+
+Intl.DateTimeFormatOptions(time_zone_name="short_offset").to_json()
+# Will return: {'timeZoneName': 'shortOffset'}
+```
+
+## Available `Intl` classes
+
+### `Intl.DateTimeFormat`
+
+#### Example usage
+
+```python
+import datetime
+import python_intl as Intl
+
+datetime_ = datetime.datetime(2026, 8, 15)
+formatter = Intl.DateTimeFormat("de-DE", {"year": "numeric", "month": "2-digit", "day": "2-digit"})
+formatter.format(datetime_)  # Will output the German format: "15.08.2026"
+```
+
+#### Compatibility
+
+| Method                              | Status | Python name                      |
+| ----------------------------------- | :----: | -------------------------------- |
+| `DateTimeFormat.format`             | ✅     |                                  |
+| `DateTimeFormat.formatToParts`      | ✅     | `DateTimeFormat.format_to_parts` |
+| `DateTimeFormat.supportedLocalesOf` | ❌     |                                  |
+| `DateTimeFormat.formatRange`        | ❌     |                                  |
+| `DateTimeFormat.formatRangeToParts` | ❌     |                                  |
+| `DateTimeFormat.resolvedOptions`    | ❌     |                                  |
+
+## Installation
+
+Be sure to be able to install `PyICU`, see the installation docs there:
+https://gitlab.pyicu.org/main/pyicu#installing-pyicu
+
+**Hint:** I mainly did run into issues with `pkg-config` not finding the ICU library,
+setting `PKG_CONFIG_PATH` accordingly helps most of the time I guess.
+
+When this is done you should be able to install `python-intl` using any package
+manager, like `pip install python-intl` or `uv add python-intl`.

{python_intl-0.1.0 → python_intl-0.3.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "python-intl"
-version = "0.1.0"
-description = "Add your description here"
+version = "0.3.1"
+description = "Python implementation of the Intl JavaScript API"
 readme = "README.md"
 license = "MIT"
 license-files = ["LICENSE"]
@@ -80,6 +80,10 @@ ignore = [
     "F401",
 ]
 
+[tool.ruff.lint.isort]
+combine-as-imports = true
+force-wrap-aliases = true
+
 [tool.uv.build-backend]
 module-name = "python_intl"
 module-root = ""

{python_intl-0.1.0 → python_intl-0.3.1}/pyproject.toml.orig

@@ -1,7 +1,7 @@
 [project]
 name = "python-intl"
-version = "0.1.0"
-description = "Add your description here"
+version = "0.3.1"
+description = "Python implementation of the Intl JavaScript API"
 readme = "README.md"
 authors = [
     { name = "David Danier", email = "david.danier@gmail.com" }
@@ -46,6 +46,10 @@ ignore = ["A001","A002","A003","ANN401","C901","N8","B008","F405","F821"]
 "conftest.py" = ["S101","ANN","F401"]
 "test_*.py" = ["S101","ANN","F401"]
 
+[tool.ruff.lint.isort]
+combine-as-imports = true
+force-wrap-aliases = true
+
 [build-system]
 requires = ["uv_build>=0.12.3,<0.13.0"]
 build-backend = "uv_build"

python_intl-0.3.1/python_intl/__init__.py

@@ -0,0 +1,6 @@
+from .datetimeformat import (
+    DateTimeFormat as DateTimeFormat,
+    DateTimeFormatOptions as DateTimeFormatOptions,
+    DateTimePatternPart as DateTimePatternPart,
+    FormatPatternNotFoundException as FormatPatternNotFoundException,
+)

python_intl-0.3.1/python_intl/datetimeformat.py

@@ -0,0 +1,433 @@
+from __future__ import annotations
+
+import dataclasses
+import datetime as dt
+from functools import cache, cached_property
+from typing import TYPE_CHECKING, Literal
+
+import icu  # type: ignore[import-untyped]
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from typing import NotRequired, TypedDict
+
+
+if TYPE_CHECKING:
+    type LocaleMatcherT = Literal["best fit", "lookup"]
+    type Hour12T = bool | None
+    type HourCycleT = Literal["h11", "h12", "h23", "h24"] | None
+
+    type EraFormatT = Literal["long", "short", "narrow"]
+    type YearFormatT = Literal["numeric", "2-digit"]
+    type MonthFormatT = Literal["numeric", "2-digit", "long", "short", "narrow"]
+    type WeekdayFormatT = Literal["long", "short", "narrow"]
+    type DayFormatT = Literal["numeric", "2-digit"]
+    type DayPeriodFormatT = Literal["long", "short", "narrow"]
+    type HourFormatT = Literal["numeric", "2-digit"]
+    type MinuteFormatT = Literal["numeric", "2-digit"]
+    type SecondFormatT = Literal["numeric", "2-digit"]
+    type FractionSecondDigitsFormatT = Literal[1, 2, 3]
+    type TimezoneNameFormatT = Literal[
+        "short",
+        "long",
+        "short_offset",
+        "long_offset",
+        "short_generic",
+        "long_generic",
+    ]
+    type AnyFormatT = (
+        EraFormatT
+        | YearFormatT
+        | MonthFormatT
+        | WeekdayFormatT
+        | DayFormatT
+        | DayPeriodFormatT
+        | HourFormatT
+        | MinuteFormatT
+        | SecondFormatT
+        | FractionSecondDigitsFormatT
+        | TimezoneNameFormatT
+    )
+
+    type PatternPartTypeT = Literal[
+        "literal", "unknown",
+        "era", "year", "month", "weekday", "day", "day_period",
+        "hour", "minute", "second", "fraction_second_digits",
+        "time_zone_name",
+    ]
+
+    # Important: Must be the same as DateTimeFormatOptions
+    # (nothing is required, as this will be used to construct a
+    # DateTimeFormatOptions instance, so default values apply then)
+    class DateTimeFormatOptionsDictT(TypedDict):
+        locale_matcher: NotRequired[LocaleMatcherT]
+        hour12: NotRequired[Hour12T]
+        hour_cycle: NotRequired[HourCycleT]
+
+        era: NotRequired[EraFormatT]
+        year: NotRequired[YearFormatT]
+        month: NotRequired[MonthFormatT]
+        weekday: NotRequired[WeekdayFormatT]
+        day: NotRequired[DayFormatT]
+        day_period: NotRequired[DayPeriodFormatT]
+        hour: NotRequired[HourFormatT]
+        minute: NotRequired[MinuteFormatT]
+        second: NotRequired[SecondFormatT]
+        fraction_second_digits: NotRequired[FractionSecondDigitsFormatT]
+        time_zone_name: NotRequired[TimezoneNameFormatT]
+
+_PATTERN_SYMBOLS = "GyYuUrQqMLqQdDFgEecabBhHkKmsSAzZOvVxX"  # includes unused
+_PATTERN_SYMBOL_TO_TYPE: dict[str, PatternPartTypeT] = {
+    "G": "era",
+    "y": "year",
+    "Y": "year",
+    "u": "year",
+    "U": "year",
+    "r": "year",
+    "M": "month",
+    "E": "weekday",
+    "e": "weekday",
+    "c": "weekday",
+    "d": "day",
+    "a": "day_period",
+    "b": "day_period",
+    "C": "day_period",
+    "h": "hour",
+    "H": "hour",
+    "k": "hour",
+    "K": "hour",
+    "m": "minute",
+    "s": "second",
+    "S": "fraction_second_digits",
+    "z": "time_zone_name",
+    "Z": "time_zone_name",
+    "O": "time_zone_name",
+    "v": "time_zone_name",
+    "V": "time_zone_name",
+    "x": "time_zone_name",
+    "X": "time_zone_name",
+}
+_PATTERN_QUOTE = "'"
+
+_COMPONENT_TO_JSON_MAP: dict[str, str] = {
+    "day_period": "dayPeriod",
+    "fraction_second_digits": "fractionalSecondDigits",
+    "time_zone_name": "timeZoneName",
+}
+_TIMEZONE_NAME_TO_JSON_MAP: dict[str | None, str] = {
+    "short_offset": "shortOffset",
+    "long_offset": "longOffset",
+    "short_generic": "shortGeneric",
+    "long_generic": "longGeneric",
+}
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True, slots=True)
+class DateTimeFormatOptions:
+    locale_matcher: LocaleMatcherT = "best fit"
+    hour12: Hour12T = None
+    hour_cycle: HourCycleT = None
+
+    era: EraFormatT | None = None
+    year: YearFormatT | None = None
+    month: MonthFormatT | None = None
+    weekday: WeekdayFormatT | None = None
+    day: DayFormatT | None = None
+    day_period: DayPeriodFormatT | None = None
+    hour: HourFormatT | None = None
+    minute: MinuteFormatT | None = None
+    second: SecondFormatT | None = None
+    fraction_second_digits: FractionSecondDigitsFormatT | None = None
+    time_zone_name: TimezoneNameFormatT | None = None
+
+    def to_json(self) -> dict[str, str | int]:
+        return {
+            k: v
+            for k, v in (
+                ("era", self.era),
+                ("year", self.year),
+                ("month", self.month),
+                ("weekday", self.weekday),
+                ("day", self.day),
+                ("dayPeriod", self.day_period),
+                ("hour", self.hour),
+                ("minute", self.minute),
+                ("second", self.second),
+                ("fractionalSecondDigits", self.fraction_second_digits),
+                ("timeZoneName", _TIMEZONE_NAME_TO_JSON_MAP.get(self.time_zone_name, self.time_zone_name)),
+            )
+            if v is not None
+        }
+
+
+def _options_to_possible_skeletons(options: DateTimeFormatOptions) -> Iterable[str]:
+    skeleton_parts: list[str | tuple[str, ...]] = []
+
+    # Note: The parts should be ordered from big to small.
+
+    match options.era:
+        case "short":
+            skeleton_parts.append("G")
+        case "long":
+            skeleton_parts.append("GGGG")
+        case "narrow":
+            skeleton_parts.append("GGGGG")
+
+    match options.year:
+        case "numeric":
+            skeleton_parts.append(("yyyy", "y"))
+        case "2-digit":
+            skeleton_parts.append("yy")
+
+    match options.month:
+        case "numeric":
+            skeleton_parts.append("M")
+        case "2-digit":
+            skeleton_parts.append("MM")
+        case "short":
+            skeleton_parts.append("MMM")
+        case "long":
+            skeleton_parts.append("MMMM")
+        case "narrow":
+            skeleton_parts.append("MMMMM")
+
+    match options.weekday:
+        case "short":
+            skeleton_parts.append("E")
+        case "long":
+            skeleton_parts.append("EEEE")
+        case "narrow":
+            skeleton_parts.append("EEEEE")
+
+    match options.day:
+        case "numeric":
+            skeleton_parts.append("d")
+        case "2-digit":
+            skeleton_parts.append("dd")
+
+    match options.day_period:
+        case "short":
+            skeleton_parts.append("B")
+        case "long":
+            skeleton_parts.append("BBBB")
+        case "narrow":
+            skeleton_parts.append("BBBBB")
+
+    match (options.hour_cycle, options.hour12, options.hour):
+        case ("h11", _, "numeric"):
+            skeleton_parts.append(("aK", "K"))
+        case ("h11", _, "2-digit"):
+            skeleton_parts.append(("aKK", "KK"))
+        case ("h12", _, "numeric"):
+            skeleton_parts.append(("ah", "h"))
+        case ("h12", _, "2-digit"):
+            skeleton_parts.append(("ahh", "hh"))
+        case ("h23", _, "numeric"):
+            skeleton_parts.append("H")
+        case ("h23", _, "2-digit"):
+            skeleton_parts.append("HH")
+        case ("h24", _, "numeric"):
+            skeleton_parts.append("k")
+        case ("h24", _, "2-digit"):
+            skeleton_parts.append("kk")
+        case (_, True, "numeric"):
+            skeleton_parts.append(("ah", "h"))
+        case (_, True, "2-digit"):
+            skeleton_parts.append(("ahh", "hh"))
+        case (_, False, "numeric"):
+            skeleton_parts.append("H")
+        case (_, False, "2-digit"):
+            skeleton_parts.append("HH")
+        case (_, _, "numeric"):
+            skeleton_parts.append("j")
+        case (_, _, "2-digit"):
+            skeleton_parts.append(("jj", "j"))
+
+    match options.minute:
+        case "numeric":
+            skeleton_parts.append("m")
+        case "2-digit":
+            skeleton_parts.append("mm")
+
+    match options.second:
+        case "numeric":
+            skeleton_parts.append("s")
+        case "2-digit":
+            skeleton_parts.append("ss")
+
+    if options.fraction_second_digits:
+        skeleton_parts.append("S" * options.fraction_second_digits)
+
+    match options.time_zone_name:
+        case "short":
+            skeleton_parts.append("z")
+        case "long":
+            skeleton_parts.append("zzzz")
+        case "short_offset":
+            skeleton_parts.append("Z")
+        case "long_offset":
+            skeleton_parts.append("ZZZZ")
+        case "short_generic":
+            skeleton_parts.append("v")
+        case "long_generic":
+            skeleton_parts.append("vvvv")
+
+    def generate_skeletons(prefix: str, remaining: list[str | tuple[str, ...]]) -> Iterable[str]:
+        if not remaining:
+            yield prefix
+            return
+
+        next_bit = remaining[0]
+        if isinstance(next_bit, tuple):
+            for next_bit_variant in next_bit:
+                yield from generate_skeletons(prefix + next_bit_variant, remaining[1:])
+        else:
+            yield from generate_skeletons(prefix + next_bit, remaining[1:])
+
+    yield from generate_skeletons("", skeleton_parts)
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True, slots=True)
+class _MatchedFormatPattern:
+    skeleton: str
+    pattern: str
+
+    def __str__(self) -> str:
+        return self.pattern
+
+
+class FormatPatternNotFoundException(Exception):
+    pass
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True, slots=True)
+class DateTimePatternPart:
+    type: PatternPartTypeT
+    value: str
+    _pattern: str | None = None
+
+    def to_json(self) -> dict[str, str]:
+        return {
+            "type": _COMPONENT_TO_JSON_MAP.get(self.type, self.type),
+            "value": self.value,
+            # note: _pattern is internal and not available in JavaScript
+        }
+
+
+@cache
+def _options_to_format_pattern(
+    locale: icu.Locale,  # ty: ignore[unresolved-attribute]
+    options: DateTimeFormatOptions,
+) -> _MatchedFormatPattern:
+    possible_skeletons = list(_options_to_possible_skeletons(options))
+
+    generator = icu.DateTimePatternGenerator.createInstance(locale)  # ty: ignore[unresolved-attribute]
+
+    # Try a perfect match
+    for skeleton in possible_skeletons:
+        pattern = generator.getPatternForSkeleton(skeleton)
+        if pattern:
+            return _MatchedFormatPattern(
+                skeleton=skeleton,
+                pattern=pattern,
+            )
+
+    # Try to find best match
+    if options.locale_matcher == "best fit":
+        for skeleton in possible_skeletons:
+            pattern = generator.getBestPattern(skeleton)
+            if pattern:
+                return _MatchedFormatPattern(
+                    skeleton=skeleton,
+                    pattern=pattern,
+                )
+
+    raise FormatPatternNotFoundException("Didn't find pattern for desired options")
+
+
+class DateTimeFormat:
+    locale: str
+    options: DateTimeFormatOptions
+
+    def __init__(
+        self,
+        locale: str,
+        options: DateTimeFormatOptions | DateTimeFormatOptionsDictT,
+    ) -> None:
+        self.locale = locale
+        if isinstance(options, DateTimeFormatOptions):
+            self.options = options
+        else:
+            self.options = DateTimeFormatOptions(**options)
+
+    @cached_property
+    def _icu_locale(self) -> icu.Locale:  # ty: ignore[unresolved-attribute]
+        return icu.Locale(self.locale)  # ty: ignore[unresolved-attribute]
+
+    @cached_property
+    def _matched_pattern(self) -> _MatchedFormatPattern:
+        return _options_to_format_pattern(self._icu_locale, self.options)
+
+    @cached_property
+    def _icu_pattern(self) -> str:
+        return self._matched_pattern.pattern
+
+    @cached_property
+    def _icu_date_format(self) -> icu.SimpleDateFormat:  # ty: ignore[unresolved-attribute]
+        return icu.SimpleDateFormat(self._icu_pattern, self._icu_locale)  # ty: ignore[unresolved-attribute]
+
+    def format(self, datetime_: dt.datetime, /) -> str:
+        return self._icu_date_format.format(datetime_)
+
+    def format_to_parts(self, datetime_: dt.datetime, /) -> Iterable[DateTimePatternPart]:
+        # Based on https://github.com/unicode-org/icu/blob/6fb634d81d10dd4667fb3fbcd1f19d9b9b926e62/icu4c/source/i18n/smpdtfmt.cpp#L1060
+        pattern = self._icu_pattern
+        in_quote = False
+        prev_char = ""
+        pattern_length = len(pattern)
+        count = 0
+        i = 0
+        literal_chars: list[str] = []
+        while i < pattern_length:
+            char = pattern[i]
+
+            if char != prev_char and count > 0:
+                yield DateTimePatternPart(
+                    type=_PATTERN_SYMBOL_TO_TYPE.get(prev_char, "unknown"),
+                    value=icu.SimpleDateFormat(prev_char * count, self._icu_locale).format(datetime_),  # ty: ignore[unresolved-attribute]
+                    _pattern=prev_char * count,
+                )
+                count = 0
+
+            if char == _PATTERN_QUOTE:
+                if (i + 1) < pattern_length and pattern[i + 1] == _PATTERN_QUOTE:
+                    literal_chars.append(_PATTERN_QUOTE)
+                    i += 1
+                else:
+                    in_quote = not in_quote
+            elif not in_quote and char in _PATTERN_SYMBOLS:
+                if literal_chars:
+                    yield DateTimePatternPart(
+                        type="literal",
+                        value="".join(literal_chars),
+                    )
+                    literal_chars = []
+                prev_char = char
+                count += 1
+            else:
+                literal_chars.append(char)
+
+            i += 1
+
+        if count > 0:
+            yield DateTimePatternPart(
+                type=_PATTERN_SYMBOL_TO_TYPE.get(prev_char, "unknown"),
+                value=icu.SimpleDateFormat(prev_char * count, self._icu_locale).format(datetime_),  # ty: ignore[unresolved-attribute]
+                _pattern=prev_char * count,
+            )
+            assert not literal_chars  # noqa: S101
+        elif literal_chars:
+            yield DateTimePatternPart(
+                type="literal",
+                value="".join(literal_chars),
+            )

python_intl-0.1.0/PKG-INFO

@@ -1,42 +0,0 @@
-Metadata-Version: 2.4
-Name: python-intl
-Version: 0.1.0
-Summary: Add your description here
-Author: David Danier
-Author-email: David Danier <david.danier@gmail.com>
-License-Expression: MIT
-License-File: LICENSE
-Requires-Dist: pyicu>=2.16.2
-Requires-Python: >=3.12
-Project-URL: Repository, https://github.com/ddanier/python-intl
-Description-Content-Type: text/markdown
-
-# `python-intl`
-
-A small library using [PyICU](https://pypi.org/project/pyicu/) to provide a Python 
-API similar to what the [`Intl` JavaScript API](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl)
-provides.
-
-**Status:** This is very much work in progress. Currently only `Intl.DateTimeFormat`
-exists and this also is not complete yet.
-
-## `Intl.DateTimeFormat`
-
-### Example usage
-
-```python
-import datetime
-from python_intl import DateTimeFormat
-
-datetime_ = datetime.datetime(2026, 8, 15)
-formatter = DateTimeFormat("de-DE", {"year": "numeric", "month": "2-digit", "day": "2-digit"})
-formatter.format(datetime_)  # Will output the German format: "15.08.2026"
-```
-
-## Installation
-
-Be sure to be able to install `PyICU`, see the installation docs there:
-https://gitlab.pyicu.org/main/pyicu#installing-pyicu
-
-**Hint:** I mainly did run into issues with `pkg-config` not finding the ICU library,
-setting `PKG_CONFIG_PATH` accordingly helps most of the time I guess.

python_intl-0.1.0/README.md

@@ -1,29 +0,0 @@
-# `python-intl`
-
-A small library using [PyICU](https://pypi.org/project/pyicu/) to provide a Python 
-API similar to what the [`Intl` JavaScript API](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl)
-provides.
-
-**Status:** This is very much work in progress. Currently only `Intl.DateTimeFormat`
-exists and this also is not complete yet.
-
-## `Intl.DateTimeFormat`
-
-### Example usage
-
-```python
-import datetime
-from python_intl import DateTimeFormat
-
-datetime_ = datetime.datetime(2026, 8, 15)
-formatter = DateTimeFormat("de-DE", {"year": "numeric", "month": "2-digit", "day": "2-digit"})
-formatter.format(datetime_)  # Will output the German format: "15.08.2026"
-```
-
-## Installation
-
-Be sure to be able to install `PyICU`, see the installation docs there:
-https://gitlab.pyicu.org/main/pyicu#installing-pyicu
-
-**Hint:** I mainly did run into issues with `pkg-config` not finding the ICU library,
-setting `PKG_CONFIG_PATH` accordingly helps most of the time I guess.

python_intl-0.1.0/python_intl/__init__.py

@@ -1 +0,0 @@
-from .datetimeformat import DateTimeFormat as DateTimeFormat

python_intl-0.1.0/python_intl/datetimeformat.py

@@ -1,358 +0,0 @@
-from __future__ import annotations
-
-import dataclasses
-import datetime as dt
-from functools import cache, cached_property
-from typing import TYPE_CHECKING, Literal, overload
-
-import icu  # type: ignore[import-untyped]
-
-if TYPE_CHECKING:
-    from collections.abc import Iterable
-    from typing import NotRequired, TypedDict
-
-
-if TYPE_CHECKING:
-    type EraFormatT = Literal["long", "short", "narrow"]
-    type YearFormatT = Literal["numeric", "2-digit"]
-    type MonthFormatT = Literal["numeric", "2-digit", "long", "short", "narrow"]
-    type WeekdayFormatT = Literal["long", "short", "narrow"]
-    type DayFormatT = Literal["numeric", "2-digit"]
-    type DayPeriodFormatT = Literal["long", "short", "narrow"]
-    type HourFormatT = Literal["numeric", "2-digit"]
-    type MinuteFormatT = Literal["numeric", "2-digit"]
-    type SecondFormatT = Literal["numeric", "2-digit"]
-    type FractionSecondDigitsFormatT = Literal[1, 2, 3]
-    type TimezoneNameFormatT = Literal[
-        "short",
-        "long",
-        "short_offset",
-        "long_offset",
-        "short_generic",
-        "long_generic",
-    ]
-    type AnyFormatT = (
-        EraFormatT
-        | YearFormatT
-        | MonthFormatT
-        | WeekdayFormatT
-        | DayFormatT
-        | DayPeriodFormatT
-        | HourFormatT
-        | MinuteFormatT
-        | SecondFormatT
-        | FractionSecondDigitsFormatT
-        | TimezoneNameFormatT
-    )
-
-    type EraPatternT = Literal["G", "GGGG", "GGGGG"]
-    type YearPatternT = Literal["y", "yy", "yyyy"]
-    type MonthPatternT = Literal["M", "MM", "MMM", "MMMM", "MMMMM"]
-    type WeekdayPatternT = Literal["E", "EEEE", "EEEEE"]
-    type DayPatternT = Literal["d", "dd"]
-    type DayPeriodPatternT = Literal["a", "aaaa", "aaaaa", "b", "bbbb", "bbbbb", "B", "BBBB", "BBBBB"]
-    type HourPatternT = Literal["j", "jj", "H", "h", "HH", "hh"]
-    type MinutePatternT = Literal["m", "mm"]
-    type SecondPatternT = Literal["s", "ss"]
-    type FractionSecondDigitsPatternT = Literal["S", "SS", "SSS"]
-    type TimezoneNamePatternT = Literal["z", "zzzz", "Z", "ZZZZ", "v", "vvvv"]
-    type AnyPatternT = (
-        EraPatternT
-        | YearPatternT
-        | MonthPatternT
-        | WeekdayPatternT
-        | DayPatternT
-        | DayPeriodPatternT
-        | HourPatternT
-        | MinutePatternT
-        | SecondPatternT
-        | FractionSecondDigitsPatternT
-        | TimezoneNamePatternT
-    )
-
-    type DatetimeFieldT = Literal[
-        "era",
-        "year",
-        "month",
-        "weekday",
-        "day",
-        "day_period",
-        "hour",
-        "minute",
-        "second",
-        "fraction_second_digits",
-        "time_zone_name",
-    ]
-
-    class DateTimeFormatOptionsDictT(TypedDict):
-        era: NotRequired[EraFormatT]
-        year: NotRequired[YearFormatT]
-        month: NotRequired[MonthFormatT]
-        weekday: NotRequired[WeekdayFormatT]
-        day: NotRequired[DayFormatT]
-        day_period: NotRequired[DayPeriodFormatT]
-        hour: NotRequired[HourFormatT]
-        minute: NotRequired[MinuteFormatT]
-        second: NotRequired[SecondFormatT]
-        fraction_second_digits: NotRequired[FractionSecondDigitsFormatT]
-        time_zone_name: NotRequired[TimezoneNameFormatT]
-
-    class OptionsToSkeletonT(TypedDict):
-        era: dict[EraFormatT, EraPatternT | tuple[EraPatternT, ...]]
-        year: dict[YearFormatT, YearPatternT | tuple[YearPatternT, ...]]
-        month: dict[MonthFormatT, MonthPatternT | tuple[MonthPatternT, ...]]
-        weekday: dict[WeekdayFormatT, WeekdayPatternT | tuple[WeekdayPatternT, ...]]
-        day: dict[DayFormatT, DayPatternT | tuple[DayPatternT, ...]]
-        day_period: dict[DayPeriodFormatT, DayPeriodPatternT | tuple[DayPeriodPatternT, ...]]
-        hour: dict[HourFormatT, HourPatternT | tuple[HourPatternT, ...]]
-        minute: dict[MinuteFormatT, MinutePatternT | tuple[MinutePatternT, ...]]
-        second: dict[SecondFormatT, SecondPatternT | tuple[SecondPatternT, ...]]
-        fraction_second_digits: dict[
-            FractionSecondDigitsFormatT,
-            FractionSecondDigitsPatternT | tuple[FractionSecondDigitsPatternT, ...],
-        ]
-        time_zone_name: dict[TimezoneNameFormatT, TimezoneNamePatternT | tuple[TimezoneNamePatternT, ...]]
-
-
-@dataclasses.dataclass(frozen=True, kw_only=True)
-class DateTimeFormatOptions:
-    era: EraFormatT | None = None
-    year: YearFormatT | None = None
-    month: MonthFormatT | None = None
-    weekday: WeekdayFormatT | None = None
-    day: DayFormatT | None = None
-    day_period: DayPeriodFormatT | None = None
-    hour: HourFormatT | None = None
-    minute: MinuteFormatT | None = None
-    second: SecondFormatT | None = None
-    fraction_second_digits: FractionSecondDigitsFormatT | None = None
-    time_zone_name: TimezoneNameFormatT | None = None
-
-    def to_json(self) -> dict[str, str | int]:
-        return {
-            k: v
-            for k, v in (
-                ("era", self.era),
-                ("year", self.year),
-                ("month", self.month),
-                ("weekday", self.weekday),
-                ("day", self.day),
-                ("day_period", self.day_period),
-                ("hour", self.hour),
-                ("minute", self.minute),
-                ("second", self.second),
-                ("fraction_second_digits", self.fraction_second_digits),
-                ("time_zone_name", self.time_zone_name),
-            )
-            if v is not None
-        }
-
-
-OPTIONS_TO_SKELETON: OptionsToSkeletonT = {
-    "era": {"short": "G", "long": "GGGG", "narrow": "GGGGG"},
-    "year": {"numeric": ("yyyy", "y"), "2-digit": "yy"},
-    "month": {"numeric": "M", "2-digit": "MM", "short": "MMM", "long": "MMMM", "narrow": "MMMMM"},
-    "weekday": {"short": "E", "long": "EEEE", "narrow": "EEEEE"},
-    "day": {"numeric": "d", "2-digit": "dd"},
-    "day_period": {
-        "short": ("a", "b", "B"),
-        "long": ("aaaa", "bbbb", "BBBB"),
-        "narrow": ("aaaaa", "bbbbb", "BBBBB"),
-    },
-    "hour": {"numeric": ("j", "H", "h"), "2-digit": ("jj", "HH", "hh")},
-    "minute": {"numeric": "m", "2-digit": "mm"},
-    "second": {"numeric": "s", "2-digit": "ss"},
-    "fraction_second_digits": {1: "S", 2: "SS", 3: "SSS"},
-    "time_zone_name": {
-        "short": "z",
-        "long": "zzzz",
-        "short_offset": "Z",
-        "long_offset": "ZZZZ",
-        "short_generic": "v",
-        "long_generic": "vvvv",
-    },
-}
-
-
-@overload
-def _option_to_skeleton_bit(
-    field: Literal["era"],
-    format: EraFormatT,
-) -> EraPatternT | tuple[EraPatternT, ...]: ...
-@overload
-def _option_to_skeleton_bit(
-    field: Literal["year"],
-    format: YearFormatT,
-) -> YearPatternT | tuple[YearPatternT, ...]: ...
-@overload
-def _option_to_skeleton_bit(
-    field: Literal["month"],
-    format: MonthFormatT,
-) -> MonthPatternT | tuple[MonthPatternT, ...]: ...
-@overload
-def _option_to_skeleton_bit(
-    field: Literal["weekday"],
-    format: WeekdayFormatT,
-) -> WeekdayPatternT | tuple[WeekdayPatternT, ...]: ...
-@overload
-def _option_to_skeleton_bit(
-    field: Literal["day"],
-    format: DayFormatT,
-) -> DayPatternT | tuple[DayPatternT, ...]: ...
-@overload
-def _option_to_skeleton_bit(
-    field: Literal["day_period"],
-    format: DayPeriodFormatT,
-) -> DayPeriodPatternT | tuple[DayPeriodPatternT, ...]: ...
-@overload
-def _option_to_skeleton_bit(
-    field: Literal["hour"],
-    format: HourFormatT,
-) -> HourPatternT | tuple[HourPatternT, ...]: ...
-@overload
-def _option_to_skeleton_bit(
-    field: Literal["minute"],
-    format: MinuteFormatT,
-) -> MinutePatternT | tuple[MinutePatternT, ...]: ...
-@overload
-def _option_to_skeleton_bit(
-    field: Literal["second"],
-    format: SecondFormatT,
-) -> SecondPatternT | tuple[SecondPatternT, ...]: ...
-@overload
-def _option_to_skeleton_bit(
-    field: Literal["fraction_second_digits"],
-    format: FractionSecondDigitsFormatT,
-) -> FractionSecondDigitsPatternT | tuple[FractionSecondDigitsPatternT, ...]: ...
-@overload
-def _option_to_skeleton_bit(
-    field: Literal["time_zone_name"],
-    format: TimezoneNameFormatT,
-) -> TimezoneNamePatternT | tuple[TimezoneNamePatternT, ...]: ...
-def _option_to_skeleton_bit(
-    field,
-    format,
-):
-    return OPTIONS_TO_SKELETON[field][format]
-
-
-def _options_to_possible_skeletons(options: DateTimeFormatOptions) -> Iterable[str]:
-    datetime_code_bits: list[str | tuple[str, ...]] = []
-
-    # For order see babel.dates.PATTERN_CHAR_ORDER
-    if options.era:
-        datetime_code_bits.append(_option_to_skeleton_bit("era", options.era))
-    if options.year:
-        datetime_code_bits.append(_option_to_skeleton_bit("year", options.year))
-    if options.month:
-        datetime_code_bits.append(_option_to_skeleton_bit("month", options.month))
-    if options.weekday:
-        datetime_code_bits.append(_option_to_skeleton_bit("weekday", options.weekday))
-    if options.day:
-        datetime_code_bits.append(_option_to_skeleton_bit("day", options.day))
-    if options.day_period:
-        datetime_code_bits.append(_option_to_skeleton_bit("day_period", options.day_period))
-    if options.hour:
-        datetime_code_bits.append(_option_to_skeleton_bit("hour", options.hour))
-    if options.minute:
-        datetime_code_bits.append(_option_to_skeleton_bit("minute", options.minute))
-    if options.second:
-        datetime_code_bits.append(_option_to_skeleton_bit("second", options.second))
-    if options.fraction_second_digits:
-        datetime_code_bits.append(
-            _option_to_skeleton_bit("fraction_second_digits", options.fraction_second_digits),
-        )
-    if options.time_zone_name:
-        datetime_code_bits.append(_option_to_skeleton_bit("time_zone_name", options.time_zone_name))
-
-    def generate_skeletons(prefix: str, remaining: list[str | tuple[str, ...]]) -> Iterable[str]:
-        if not remaining:
-            yield prefix
-            return
-
-        next_bit = remaining[0]
-        if isinstance(next_bit, tuple):
-            for next_bit_variant in next_bit:
-                yield from generate_skeletons(prefix + next_bit_variant, remaining[1:])
-        else:
-            yield from generate_skeletons(prefix + next_bit, remaining[1:])
-
-    yield from generate_skeletons("", datetime_code_bits)
-
-
-@dataclasses.dataclass(frozen=True, kw_only=True)
-class MatchedFormatPattern:
-    skeleton: str
-    pattern: str
-
-    def __str__(self) -> str:
-        return self.pattern
-
-
-class FormatPatternNotFoundException(Exception):
-    pass
-
-
-@cache
-def _options_to_format_pattern(
-    locale: icu.Locale,  # ty: ignore[unresolved-attribute]
-    options: DateTimeFormatOptions,
-) -> MatchedFormatPattern:
-    possible_skeletons = list(_options_to_possible_skeletons(options))
-
-    generator = icu.DateTimePatternGenerator.createInstance(locale)  # ty: ignore[unresolved-attribute]
-
-    # Try a perfect match
-    for skeleton in possible_skeletons:
-        pattern = generator.getPatternForSkeleton(skeleton)
-        if pattern:
-            return MatchedFormatPattern(
-                skeleton=skeleton,
-                pattern=pattern,
-            )
-
-    # Try to find best match
-    for skeleton in possible_skeletons:
-        pattern = generator.getBestPattern(skeleton)
-        if pattern:
-            return MatchedFormatPattern(
-                skeleton=skeleton,
-                pattern=pattern,
-            )
-
-    raise FormatPatternNotFoundException("Didn't find pattern for desired options")
-
-
-class DateTimeFormat:
-    locale: str
-    options: DateTimeFormatOptions
-
-    def __init__(
-        self,
-        locale: str,
-        options: DateTimeFormatOptions | DateTimeFormatOptionsDictT,
-    ) -> None:
-        self.locale = locale
-        if isinstance(options, DateTimeFormatOptions):
-            self.options = options
-        else:
-            self.options = DateTimeFormatOptions(**options)
-
-    @cached_property
-    def icu_locale(self) -> icu.Locale:  # ty: ignore[unresolved-attribute]
-        return icu.Locale(self.locale)  # ty: ignore[unresolved-attribute]
-
-    @cached_property
-    def matched_pattern(self) -> MatchedFormatPattern:
-        return _options_to_format_pattern(self.icu_locale, self.options)
-
-    @cached_property
-    def icu_pattern(self) -> str:
-        return self.matched_pattern.pattern
-
-    @cached_property
-    def icu_date_format(self) -> icu.SimpleDateFormat:  # ty: ignore[unresolved-attribute]
-        return icu.SimpleDateFormat(self.icu_pattern, self.icu_locale)  # ty: ignore[unresolved-attribute]
-
-    def format(self, datetime_: dt.datetime, /) -> str:
-        return self.icu_date_format.format(datetime_)