python-intl 0.7.1__tar.gz → 0.9.0__tar.gz

{python_intl-0.7.1 → python_intl-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-intl
-Version: 0.7.1
+Version: 0.9.0
 Summary: Python implementation of the Intl JavaScript API
 Author: David Danier
 Author-email: David Danier <david.danier@gmail.com>
@@ -54,6 +54,55 @@ Intl.DateTimeFormatOptions(time_zone_name="short_offset").to_json()
 
 ## Available `Intl` classes
 
+### `Intl.Locale`
+
+#### Example usage
+
+```python
+import datetime as dt
+import python_intl as Intl
+
+locale = Intl.Locale("de-DE")
+```
+
+#### Compatibility
+
+`Locale` currently does not support any methods or options. It is mainly there to
+allow using the locale class instead of a string with the other classes. There will
+be more later.
+
+### `Intl.NumberFormat`
+
+#### Example usage
+
+```python
+import python_intl as Intl
+
+# Format liters
+number = 1234.567
+formatter = Intl.NumberFormat("de-DE", {"style": "unit", "unit": "liter"})
+formatter.format(number)
+# Result = "1.234,567 l"
+
+# Format euros
+number = 1234.567
+formatter = Intl.NumberFormat("de-DE", {"style": "currency", "currency": "EUR"})
+formatter.format(number)
+# Result = "1.234,57 €"
+# Note: Result will be automatically rounded to two decimal places, as EUR defines.
+```
+
+#### Compatibility
+
+| Method                            | Status | Python name                          |
+| --------------------------------- | :----: | ------------------------------------ |
+| `NumberFormat.format`             | ✅     |                                      |
+| `NumberFormat.formatToParts`      | ❌     | `NumberFormat.format_to_parts`       |
+| `NumberFormat.supportedLocalesOf` | ❌     |                                      |
+| `NumberFormat.formatRange`        | ✅     | `NumberFormat.format_range`          |
+| `NumberFormat.formatRangeToParts` | ❌     | `NumberFormat.format_range_to_parts` |
+| `NumberFormat.resolvedOptions`    | ❌     |                                      |
+
 ### `Intl.DateTimeFormat`
 
 #### Example usage
@@ -121,7 +170,18 @@ 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.
+setting `PKG_CONFIG_PATH` accordingly helps most of the time I guess. See [`.envrc`](.envrc)
+for how to set this up correctly on `nix` based systems.
 
 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`.
+
+## Contributing
+
+If you want to contribute to this project, feel free to just fork the project,
+create a dev branch in your fork and then create a pull request (PR). If you
+are unsure about whether your changes really suits the project please create an
+issue first, to talk about this.
+
+Please do not contribute AI generated code unless we explicitly talked about
+this and agreed upon doing so first. In general I do not want AI contributions.

{python_intl-0.7.1 → python_intl-0.9.0}/README.md

@@ -41,6 +41,55 @@ Intl.DateTimeFormatOptions(time_zone_name="short_offset").to_json()
 
 ## Available `Intl` classes
 
+### `Intl.Locale`
+
+#### Example usage
+
+```python
+import datetime as dt
+import python_intl as Intl
+
+locale = Intl.Locale("de-DE")
+```
+
+#### Compatibility
+
+`Locale` currently does not support any methods or options. It is mainly there to
+allow using the locale class instead of a string with the other classes. There will
+be more later.
+
+### `Intl.NumberFormat`
+
+#### Example usage
+
+```python
+import python_intl as Intl
+
+# Format liters
+number = 1234.567
+formatter = Intl.NumberFormat("de-DE", {"style": "unit", "unit": "liter"})
+formatter.format(number)
+# Result = "1.234,567 l"
+
+# Format euros
+number = 1234.567
+formatter = Intl.NumberFormat("de-DE", {"style": "currency", "currency": "EUR"})
+formatter.format(number)
+# Result = "1.234,57 €"
+# Note: Result will be automatically rounded to two decimal places, as EUR defines.
+```
+
+#### Compatibility
+
+| Method                            | Status | Python name                          |
+| --------------------------------- | :----: | ------------------------------------ |
+| `NumberFormat.format`             | ✅     |                                      |
+| `NumberFormat.formatToParts`      | ❌     | `NumberFormat.format_to_parts`       |
+| `NumberFormat.supportedLocalesOf` | ❌     |                                      |
+| `NumberFormat.formatRange`        | ✅     | `NumberFormat.format_range`          |
+| `NumberFormat.formatRangeToParts` | ❌     | `NumberFormat.format_range_to_parts` |
+| `NumberFormat.resolvedOptions`    | ❌     |                                      |
+
 ### `Intl.DateTimeFormat`
 
 #### Example usage
@@ -108,7 +157,18 @@ 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.
+setting `PKG_CONFIG_PATH` accordingly helps most of the time I guess. See [`.envrc`](.envrc)
+for how to set this up correctly on `nix` based systems.
 
 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`.
+
+## Contributing
+
+If you want to contribute to this project, feel free to just fork the project,
+create a dev branch in your fork and then create a pull request (PR). If you
+are unsure about whether your changes really suits the project please create an
+issue first, to talk about this.
+
+Please do not contribute AI generated code unless we explicitly talked about
+this and agreed upon doing so first. In general I do not want AI contributions.

{python_intl-0.7.1 → python_intl-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-intl"
-version = "0.7.1"
+version = "0.9.0"
 description = "Python implementation of the Intl JavaScript API"
 readme = "README.md"
 license = "MIT"
@@ -17,11 +17,14 @@ Repository = "https://github.com/ddanier/python-intl"
 
 [dependency-groups]
 dev = [
+    "basedpyright>=1.40.1",
     "mypy>=2.3.1",
+    "pylsp-mypy>=0.8.0",
     "pyright>=1.1.411",
     "pytest>=9.1.1",
     "pytest-cov>=7.1.0",
     "pytest-xdist>=3.8.0",
+    "python-lsp-server>=1.15.0",
     "ruff>=0.16.3",
     "tox>=4.60.0",
     "ty>=0.0.72",
@@ -35,59 +38,86 @@ markers = [
 
 [tool.ruff]
 line-length = 115
-target-version = "py312"
 output-format = "grouped"
 
 [tool.ruff.lint]
 select = [
-    "F",
+    "A",
+    "ANN",
+    "ARG",
+    "ASYNC",
+    "B",
+    "BLE",
+    "C4",
+    "COM",
+    "DTZ",
     "E",
-    "W",
-    "C",
+    "EM",
+    "EXE",
+    "F",
+    "FA",
+    "FBT",
+    "FURB",
     "I",
+    "ICN",
+    "ISC",
     "N",
-    "UP",
-    "ANN",
+    "PERF",
+    "PIE",
+    "PL",
+    "PT",
+    "PTH",
+    "Q",
+    "RSE",
+    "RUF",
     "S",
-    "B",
-    "A",
-    "COM",
-    "C4",
+    "SIM",
+    "SLOT",
+    "T10",
     "T20",
-    "PT",
-    "ARG",
+    "TC",
     "TD",
-    "RUF",
-]
-ignore = [
-    "A001",
-    "A002",
-    "A003",
-    "ANN401",
-    "C901",
-    "N8",
-    "B008",
-    "F405",
-    "F821",
+    "TID",
+    "TRY",
+    "UP",
+    "W",
 ]
+ignore = ["N812"]
 
 [tool.ruff.lint.per-file-ignores]
-"__init__.py" = ["F401"]
-"conftest.py" = [
+"test_*.py" = [
     "S101",
-    "ANN",
-    "F401",
+    "ANN201",
 ]
-"test_*.py" = [
+"conftest.py" = [
     "S101",
-    "ANN",
-    "F401",
+    "ANN201",
 ]
 
 [tool.ruff.lint.isort]
 combine-as-imports = true
 force-wrap-aliases = true
 
+[tool.ty.analysis]
+replace-imports-with-any = ["icu.**"]
+
+[[tool.mypy.overrides]]
+module = ["icu.*"]
+ignore_missing_imports = true
+
+[tool.basedpyright]
+pythonVersion = "3.12"
+reportAny = false
+reportMatchNotExhaustive = false
+reportUnknownLambdaType = false
+reportPrivateUsage = false
+allowedUntypedLibraries = ["icu"]
+reportAttributeAccessIssue = false
+reportUnknownVariableType = false
+reportUnknownMemberType = false
+reportUnknownParameterType = false
+reportUnknownArgumentType = false
+
 [tool.uv.build-backend]
 module-name = "python_intl"
 module-root = ""

python_intl-0.9.0/pyproject.toml.orig

@@ -0,0 +1,131 @@
+[project]
+name = "python-intl"
+version = "0.9.0"
+description = "Python implementation of the Intl JavaScript API"
+readme = "README.md"
+authors = [
+    { name = "David Danier", email = "david.danier@gmail.com" }
+]
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+dependencies = [
+    "pyicu>=2.16.2",
+]
+
+[project.urls]
+Repository = "https://github.com/ddanier/python-intl"
+
+[dependency-groups]
+dev = [
+    "basedpyright>=1.40.1",
+    "mypy>=2.3.1",
+    "pylsp-mypy>=0.8.0",
+    "pyright>=1.1.411",
+    "pytest>=9.1.1",
+    "pytest-cov>=7.1.0",
+    "pytest-xdist>=3.8.0",
+    "python-lsp-server>=1.15.0",
+    "ruff>=0.16.3",
+    "tox>=4.60.0",
+    "ty>=0.0.72",
+]
+
+[tool.pytest.ini_options]
+markers = [
+    "unit: mark a test as a unit test",
+    "node: mark tests jun against the node/JS implementation",
+]
+
+[tool.ruff]
+line-length = 115
+output-format = "grouped"
+
+[tool.ruff.lint]
+select = [
+    "A",     # flake8-builtins
+    "ANN",   # flake8-annotations
+    "ARG",   # flake8-unused-arguments
+    "ASYNC", # flake8-async
+    "B",     # flake8-bugbear
+    "BLE",   # flake8-blind-except
+    "C4",    # flake8-comprehensions
+    "COM",   # flake8-commas
+    "DTZ",   # flake8-datetimez
+    "E",     # pycodestyle errors
+    "EM",    # flake8-errmsg
+    "EXE",   # flake8-executable
+    "F",     # pyflakes
+    "FA",    # flake8-future-annotations
+    "FBT",   # flake8-boolean-trap
+    "FURB",  # refurb
+    "I",     # isort
+    "ICN",   # flake8-import-conventions
+    "ISC",   # flake8-implicit-str-concat
+    "N",     # pep8-naming
+    "PERF",  # perflint
+    "PIE",   # flake8-pie
+    "PL",    # pylint
+    "PT",    # flake8-pytest-style
+    "PTH",   # flake8-use-pathlib
+    "Q",     # flake8-quotes
+    "RSE",   # flake8-raise
+    "RUF",   # ruff-specific rules
+    "S",     # flake8-bandit
+    "SIM",   # flake8-simplify
+    "SLOT",  # flake8-slots
+    "T10",   # flake8-debugger
+    "T20",   # flake8-print
+    "TC",    # flake8-type-checking
+    "TD",    # flake8-todos
+    "TID",   # flake8-tidy-imports
+    "TRY",   # tryceratops
+    "UP",    # pyupgrade
+    "W",     # pycodestyle warnings
+]
+ignore = [
+    "N812", # Allow using "import python_intl as Intl"
+]
+
+[tool.ruff.lint.per-file-ignores]
+"test_*.py" = [
+    "S101",   # Allow usage of assert in tests
+    "ANN201", # Don't require to define return types in tests
+]
+"conftest.py" = [
+    "S101",   # Allow usage of assert in tests
+    "ANN201", # Don't require to define return types in tests
+]
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+force-wrap-aliases = true
+
+[tool.ty.analysis]
+replace-imports-with-any = ["icu.**"]
+
+[[tool.mypy.overrides]]
+module = ["icu.*"]
+ignore_missing_imports = true
+
+[tool.basedpyright]
+pythonVersion = "3.12"
+reportAny = false
+reportMatchNotExhaustive = false
+reportUnknownLambdaType = false
+reportPrivateUsage = false
+# The following are only necessary cause of untyped icu library
+allowedUntypedLibraries = ["icu"]
+reportAttributeAccessIssue = false
+reportUnknownVariableType = false
+reportUnknownMemberType = false
+reportUnknownParameterType = false
+reportUnknownArgumentType = false
+
+[build-system]
+requires = ["uv_build>=0.12.3,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "python_intl"
+module-root = ""

{python_intl-0.7.1 → python_intl-0.9.0}/python_intl/__init__.py

@@ -7,5 +7,10 @@ from .datetimeformat import (
     DateTimeFormatOptions as DateTimeFormatOptions,
     DateTimeIntervalPatternPart as DateTimeIntervalPatternPart,
     DateTimePatternPart as DateTimePatternPart,
-    FormatPatternNotFoundException as FormatPatternNotFoundException,
+    FormatPatternNotFoundError as FormatPatternNotFoundError,
+)
+from .numberformat import (
+    InvalidNumberFormatOptionError as InvalidNumberFormatOptionError,
+    NumberFormat as NumberFormat,
+    NumberFormatOptions as NumberFormatOptions,
 )

python_intl-0.9.0/python_intl/_types.py

@@ -0,0 +1,94 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Literal
+
+    type LocaleMatcherT = Literal["best fit", "lookup"]
+    type Hour12T = bool
+    type HourCycleT = Literal["h11", "h12", "h23", "h24"]
+
+    # datetime
+    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",
+    ]
+
+    # number
+    type StyleT = Literal["decimal", "currency", "percent", "unit"]
+    type CurrencyT = str  # 3 char ISO code
+    type CurrencyDisplayT = Literal["code", "symbol", "narrow_symbol", "name"]
+    type CurrencySignT = Literal["standard", "accounting"]
+    type UnitT = Literal[
+        # see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/supportedValuesOf#supported_unit_identifiers
+        # for Intl reference
+        # see https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1MeasureUnit.html
+        # for ICU reference
+        "acre",
+        "bit",
+        "byte",
+        "celsius",
+        "centimeter",
+        "day",
+        "degree",
+        "fahrenheit",
+        "fluid-ounce",
+        "foot",
+        "gallon",
+        "gigabit",
+        "gigabyte",
+        "gram",
+        "hectare",
+        "hour",
+        "inch",
+        "kilobit",
+        "kilobyte",
+        "kilogram",
+        "kilometer",
+        "liter",
+        "megabit",
+        "megabyte",
+        "meter",
+        "microsecond",
+        "mile",
+        "mile-scandinavian",
+        "milliliter",
+        "millimeter",
+        "millisecond",
+        "minute",
+        "month",
+        "nanosecond",
+        "ounce",
+        "percent",
+        "petabyte",
+        "pound",
+        "second",
+        "stone",
+        "terabit",
+        "terabyte",
+        "week",
+        "yard",
+        "year",
+    ]
+    type UnitDisplayT = Literal["short", "narrow", "long"]
+
+    # collator
+    # type UsageT = Literal["sort", "search"]
+    # type CollationT = Literal["emoji", "pinyin", "stroke"]
+    type CaseFirstT = Literal["upper", "lower", "false"]
+    type SensitivityT = Literal["base", "accent", "case", "variant"]
+
+    type ComparisonResultT = Literal[-1, 0, 1]

{python_intl-0.7.1 → python_intl-0.9.0}/python_intl/collator.py

@@ -2,25 +2,18 @@ from __future__ import annotations
 
 import dataclasses
 import functools
-from collections.abc import Callable, Iterable
 from functools import cached_property
-from typing import TYPE_CHECKING, Literal, overload
+from typing import TYPE_CHECKING, overload
 
-import icu  # type: ignore[import-untyped]
-
-if TYPE_CHECKING:
-    from typing import NotRequired, TypedDict
+import icu
 
+from .locale import Locale
 
 if TYPE_CHECKING:
-    from ._types import LocaleMatcherT
-
-    # type UsageT = Literal["sort", "search"]
-    # type CollationT = Literal["emoji", "pinyin", "stroke"]
-    type CaseFirstT = Literal["upper", "lower", "false"]
-    type SensitivityT = Literal["base", "accent", "case", "variant"]
+    from collections.abc import Callable, Iterable
+    from typing import NotRequired, TypedDict
 
-    type ComparisonResultT = Literal[-1, 0, 1]
+    from ._types import CaseFirstT, ComparisonResultT, LocaleMatcherT, SensitivityT
 
     # Important: Must be the same as CollatorOptions
     # (nothing is required, as this will be used to construct a
@@ -61,23 +54,26 @@ class CollatorOptions:
         }
 
 
-_COLLATOR_RESULT_TO_RESULT: dict[icu.UCollationResult, ComparisonResultT] = {  # ty: ignore[unresolved-attribute]
-    icu.UCollationResult.LESS: -1,  # ty: ignore[unresolved-attribute]
-    icu.UCollationResult.EQUAL: 0,  # ty: ignore[unresolved-attribute]
-    icu.UCollationResult.GREATER: 1,  # ty: ignore[unresolved-attribute]
+_COLLATOR_RESULT_TO_RESULT: dict[icu.UCollationResult, ComparisonResultT] = {
+    icu.UCollationResult.LESS: -1,
+    icu.UCollationResult.EQUAL: 0,
+    icu.UCollationResult.GREATER: 1,
 }
 
 
 class Collator:
-    locale: str
+    locale: Locale
     options: CollatorOptions
 
     def __init__(
         self,
-        locale: str,
+        locale: Locale | str,
         options: CollatorOptions | CollatorOptionsDictT | None = None,
     ) -> None:
-        self.locale = locale
+        if isinstance(locale, Locale):
+            self.locale = locale
+        else:
+            self.locale = Locale(locale)
         if options is None:
             self.options = CollatorOptions()
         elif isinstance(options, CollatorOptions):
@@ -86,41 +82,37 @@ class Collator:
             self.options = CollatorOptions(**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 _icu_collator(self) -> icu.Collator:  # ty: ignore[unresolved-attribute]
-        collator = icu.Collator.createInstance(self._icu_locale)  # ty: ignore[unresolved-attribute]
+    def _icu_collator(self) -> icu.Collator:
+        collator = icu.Collator.createInstance(self.locale._icu_locale)
 
         if self.options.numeric:
-            collator.setAttribute(icu.UCollAttribute.NUMERIC_COLLATION, icu.UCollAttributeValue.ON)  # ty: ignore[unresolved-attribute]
+            collator.setAttribute(icu.UCollAttribute.NUMERIC_COLLATION, icu.UCollAttributeValue.ON)
 
         if (
             self.options.ignore_punctuation
             or (
                 self.options.ignore_punctuation is None
-                and self._icu_locale.getLanguage() == "th"
+                and self.locale._icu_locale.getLanguage() == "th"
             )
         ):
-            collator.setAttribute(icu.UCollAttribute.ALTERNATE_HANDLING, icu.UCollAttributeValue.SHIFTED)  # ty: ignore[unresolved-attribute]
+            collator.setAttribute(icu.UCollAttribute.ALTERNATE_HANDLING, icu.UCollAttributeValue.SHIFTED)
 
         match self.options.case_first:
             case "upper":
-                collator.setAttribute(icu.UCollAttribute.CASE_FIRST, icu.UCollAttributeValue.UPPER_FIRST)  # ty: ignore[unresolved-attribute]
+                collator.setAttribute(icu.UCollAttribute.CASE_FIRST, icu.UCollAttributeValue.UPPER_FIRST)
             case "lower":
-                collator.setAttribute(icu.UCollAttribute.CASE_FIRST, icu.UCollAttributeValue.LOWER_FIRST)  # ty: ignore[unresolved-attribute]
+                collator.setAttribute(icu.UCollAttribute.CASE_FIRST, icu.UCollAttributeValue.LOWER_FIRST)
 
-        collator.setAttribute(icu.UCollAttribute.NORMALIZATION_MODE, icu.UCollAttributeValue.ON)  # ty: ignore[unresolved-attribute]
+        collator.setAttribute(icu.UCollAttribute.NORMALIZATION_MODE, icu.UCollAttributeValue.ON)
         match self.options.sensitivity:
             case "base":
-                collator.setAttribute(icu.UCollAttribute.STRENGTH, icu.UCollAttributeValue.PRIMARY)  # ty: ignore[unresolved-attribute]
+                collator.setAttribute(icu.UCollAttribute.STRENGTH, icu.UCollAttributeValue.PRIMARY)
             case "accent":
-                collator.setAttribute(icu.UCollAttribute.STRENGTH, icu.UCollAttributeValue.SECONDARY)  # ty: ignore[unresolved-attribute]
+                collator.setAttribute(icu.UCollAttribute.STRENGTH, icu.UCollAttributeValue.SECONDARY)
             case "case":
-                collator.setAttribute(icu.UCollAttribute.STRENGTH, icu.UCollAttributeValue.TERTIARY)  # ty: ignore[unresolved-attribute]
+                collator.setAttribute(icu.UCollAttribute.STRENGTH, icu.UCollAttributeValue.TERTIARY)
             case "variant":
-                collator.setAttribute(icu.UCollAttribute.STRENGTH, icu.UCollAttributeValue.QUATERNARY)  # ty: ignore[unresolved-attribute]
+                collator.setAttribute(icu.UCollAttribute.STRENGTH, icu.UCollAttributeValue.QUATERNARY)
 
         return collator
 
@@ -131,7 +123,7 @@ class Collator:
     def sorted(self, items: Iterable[str], /, key: None = None) -> Iterable[str]: ...
     @overload
     def sorted[T](self, items: Iterable[T], /, key: Callable[[T], str]) -> Iterable[T]: ...
-    def sorted(self, items, /, key = None):
+    def sorted(self, items, /, key = None):  # pyright: ignore[reportInconsistentOverload]
         return sorted(
             items,
             key=functools.cmp_to_key(

{python_intl-0.7.1 → python_intl-0.9.0}/python_intl/datetimeformat.py

@@ -1,56 +1,36 @@
 from __future__ import annotations
 
 import dataclasses
-import datetime as dt
 from functools import cache, cached_property
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Literal, override
 
-import icu  # type: ignore[import-untyped]
+import icu
+
+from .locale import Locale
 
 if TYPE_CHECKING:
+    import datetime as dt
     from collections.abc import Iterable
     from typing import NotRequired, TypedDict
 
-
-if TYPE_CHECKING:
-    from ._types import LocaleMatcherT
-
-    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
+    from ._types import (
+        DayFormatT,
+        DayPeriodFormatT,
+        EraFormatT,
+        FractionSecondDigitsFormatT,
+        Hour12T,
+        HourCycleT,
+        HourFormatT,
+        LocaleMatcherT,
+        MinuteFormatT,
+        MonthFormatT,
+        SecondFormatT,
+        TimezoneNameFormatT,
+        WeekdayFormatT,
+        YearFormatT,
     )
 
-    type PatternPartTypeT = Literal[
+    type DatetimePatternPartTypeT = Literal[
         "literal", "unknown",
         "era", "year", "month", "weekday", "day", "day_period",
         "hour", "minute", "second", "fraction_second_digits",
@@ -78,7 +58,7 @@ if TYPE_CHECKING:
         time_zone_name: NotRequired[TimezoneNameFormatT]
 
 _PATTERN_SYMBOLS = "GyYuUrQqMLqQdDFgEecabBhHkKmsSAzZOvVxX"  # includes unused
-_PATTERN_SYMBOL_TO_TYPE: dict[str, PatternPartTypeT] = {
+_PATTERN_SYMBOL_TO_TYPE: dict[str, DatetimePatternPartTypeT] = {
     "G": "era",
     "y": "year",
     "Y": "year",
@@ -92,6 +72,7 @@ _PATTERN_SYMBOL_TO_TYPE: dict[str, PatternPartTypeT] = {
     "d": "day",
     "a": "day_period",
     "b": "day_period",
+    "B": "day_period",
     "C": "day_period",
     "h": "hour",
     "H": "hour",
@@ -108,21 +89,27 @@ _PATTERN_SYMBOL_TO_TYPE: dict[str, PatternPartTypeT] = {
     "x": "time_zone_name",
     "X": "time_zone_name",
 }
-_PATTERN_FIELD_TO_TYPE: dict[icu.UDateTimePatternField, PatternPartTypeT] = {  # ty: ignore[unresolved-attribute]
-    icu.DateFormat.ERA_FIELD: "era",  # ty: ignore[unresolved-attribute]
-    icu.DateFormat.YEAR_FIELD: "year",  # ty: ignore[unresolved-attribute]
-    icu.DateFormat.MONTH_FIELD: "month",  # ty: ignore[unresolved-attribute]
-    icu.DateFormat.DAY_OF_WEEK_FIELD: "weekday",  # ty: ignore[unresolved-attribute]
-    icu.DateFormat.DATE_FIELD: "day",  # ty: ignore[unresolved-attribute]
-    icu.DateFormat.AM_PM_FIELD: "day_period",  # ty: ignore[unresolved-attribute]
-    icu.DateFormat.HOUR0_FIELD: "hour",  # ty: ignore[unresolved-attribute]
-    icu.DateFormat.HOUR1_FIELD: "hour",  # ty: ignore[unresolved-attribute]
-    icu.DateFormat.HOUR_OF_DAY0_FIELD: "hour",  # ty: ignore[unresolved-attribute]
-    icu.DateFormat.HOUR_OF_DAY1_FIELD: "hour",  # ty: ignore[unresolved-attribute]
-    icu.DateFormat.MINUTE_FIELD: "minute",  # ty: ignore[unresolved-attribute]
-    icu.DateFormat.SECOND_FIELD: "second",  # ty: ignore[unresolved-attribute]
-    icu.DateFormat.MILLISECOND_FIELD: "fraction_second_digits",  # ty: ignore[unresolved-attribute]
-    icu.DateFormat.TIMEZONE_FIELD: "time_zone_name",  # ty: ignore[unresolved-attribute]
+_PATTERN_FIELD_TO_TYPE: dict[icu.UDateTimePatternField, DatetimePatternPartTypeT] = {
+    icu.DateFormat.ERA_FIELD: "era",
+    icu.DateFormat.YEAR_FIELD: "year",
+    icu.DateFormat.MONTH_FIELD: "month",
+    icu.DateFormat.DAY_OF_WEEK_FIELD: "weekday",
+    icu.DateFormat.DATE_FIELD: "day",
+    icu.DateFormat.AM_PM_FIELD: "day_period",
+    # TODO(ddanier): Use this instead once PyICU has those values in the enum:
+    # https://gitlab.pyicu.org/main/pyicu/-/work_items/180
+    # icu.DateFormat.AM_PM_MIDNIGHT_NOON_FIELD: "day_period",
+    # icu.DateFormat.FLEXIBLE_DAY_PERIOD_FIELD: "day_period",
+    35: "day_period",
+    36: "day_period",
+    icu.DateFormat.HOUR0_FIELD: "hour",
+    icu.DateFormat.HOUR1_FIELD: "hour",
+    icu.DateFormat.HOUR_OF_DAY0_FIELD: "hour",
+    icu.DateFormat.HOUR_OF_DAY1_FIELD: "hour",
+    icu.DateFormat.MINUTE_FIELD: "minute",
+    icu.DateFormat.SECOND_FIELD: "second",
+    icu.DateFormat.MILLISECOND_FIELD: "fraction_second_digits",
+    icu.DateFormat.TIMEZONE_FIELD: "time_zone_name",
 }
 _PATTERN_QUOTE = "'"
 
@@ -146,8 +133,8 @@ _SOURCE_TO_JSON_MAP: dict[str, str] = {
 @dataclasses.dataclass(frozen=True, kw_only=True, slots=True)
 class DateTimeFormatOptions:
     locale_matcher: LocaleMatcherT = "best fit"
-    hour12: Hour12T = None
-    hour_cycle: HourCycleT = None
+    hour12: Hour12T | None = None
+    hour_cycle: HourCycleT | None = None
 
     era: EraFormatT | None = None
     year: YearFormatT | None = None
@@ -165,6 +152,10 @@ class DateTimeFormatOptions:
         return {
             k: v
             for k, v in (
+                ("localeMatcher", self.locale_matcher),
+                ("hour12", self.hour12),
+                ("hourCycle", self.hour_cycle),
+
                 ("era", self.era),
                 ("year", self.year),
                 ("month", self.month),
@@ -181,7 +172,7 @@ class DateTimeFormatOptions:
         }
 
 
-def _options_to_possible_skeletons(options: DateTimeFormatOptions) -> Iterable[str]:
+def _options_to_possible_skeletons(options: DateTimeFormatOptions) -> Iterable[str]:  # noqa: PLR0912, PLR0915
     skeleton_parts: list[str | tuple[str, ...]] = []
 
     # Note: The parts should be ordered from big to small.
@@ -313,17 +304,18 @@ class _MatchedFormatPattern:
     skeleton: str
     pattern: str
 
+    @override
     def __str__(self) -> str:
         return self.pattern
 
 
-class FormatPatternNotFoundException(Exception):
+class FormatPatternNotFoundError(Exception):
     pass
 
 
 @dataclasses.dataclass(kw_only=True, frozen=True, slots=True)
 class DateTimePatternPart:
-    type: PatternPartTypeT
+    type: DatetimePatternPartTypeT
     value: str
     _pattern: str | None = None
 
@@ -337,7 +329,7 @@ class DateTimePatternPart:
 
 @dataclasses.dataclass(kw_only=True, frozen=True, slots=True)
 class DateTimeIntervalPatternPart:
-    type: PatternPartTypeT
+    type: DatetimePatternPartTypeT
     value: str
     source: Literal["start_range", "end_range", "shared"]
 
@@ -351,12 +343,12 @@ class DateTimeIntervalPatternPart:
 
 @cache
 def _options_to_format_pattern(
-    locale: icu.Locale,  # ty: ignore[unresolved-attribute]
+    locale: icu.Locale,
     options: DateTimeFormatOptions,
 ) -> _MatchedFormatPattern:
     possible_skeletons = list(_options_to_possible_skeletons(options))
 
-    generator = icu.DateTimePatternGenerator.createInstance(locale)  # ty: ignore[unresolved-attribute]
+    generator = icu.DateTimePatternGenerator.createInstance(locale)
 
     # Try a perfect match
     for skeleton in possible_skeletons:
@@ -377,7 +369,8 @@ def _options_to_format_pattern(
                     pattern=pattern,
                 )
 
-    raise FormatPatternNotFoundException("Didn't find pattern for desired options")
+    error = "Didn't find pattern for desired options"
+    raise FormatPatternNotFoundError(error)
 
 
 @dataclasses.dataclass(kw_only=True, frozen=True, slots=True)
@@ -390,7 +383,7 @@ class _PartSpan:
         return cls(start=0, end=0)
 
     @classmethod
-    def from_constrained_fieldposition(cls, position: icu.ConstrainedFieldPosition) -> _PartSpan:  # ty: ignore[unresolved-attribute]
+    def from_constrained_fieldposition(cls, position: icu.ConstrainedFieldPosition) -> _PartSpan:
         return cls(start=position.getStart(), end=position.getLimit())
 
     def __contains__(self, inner: _PartSpan) -> bool:
@@ -398,15 +391,18 @@ class _PartSpan:
 
 
 class DateTimeFormat:
-    locale: str
+    locale: Locale
     options: DateTimeFormatOptions
 
     def __init__(
         self,
-        locale: str,
+        locale: Locale | str,
         options: DateTimeFormatOptions | DateTimeFormatOptionsDictT | None = None,
     ) -> None:
-        self.locale = locale
+        if isinstance(locale, Locale):
+            self.locale = locale
+        else:
+            self.locale = Locale(locale)
         if options is None:
             self.options = DateTimeFormatOptions()
         elif isinstance(options, DateTimeFormatOptions):
@@ -414,21 +410,17 @@ class DateTimeFormat:
         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)
+        return _options_to_format_pattern(self.locale._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 _icu_date_format(self) -> icu.SimpleDateFormat:
+        return icu.SimpleDateFormat(self._icu_pattern, self.locale._icu_locale)
 
     def format(self, datetime_: dt.datetime, /) -> str:
         return self._icu_date_format.format(datetime_)
@@ -448,7 +440,7 @@ class DateTimeFormat:
             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]
+                    value=icu.SimpleDateFormat(prev_char * count, self.locale._icu_locale).format(datetime_),
                     _pattern=prev_char * count,
                 )
                 count = 0
@@ -476,7 +468,7 @@ class DateTimeFormat:
         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]
+                value=icu.SimpleDateFormat(prev_char * count, self.locale._icu_locale).format(datetime_),
                 _pattern=prev_char * count,
             )
             assert not literal_chars  # noqa: S101
@@ -487,16 +479,16 @@ class DateTimeFormat:
             )
 
     @cached_property
-    def _icu_dateinterval_format(self) -> icu.DateIntervalFormat:  # ty: ignore[unresolved-attribute]
+    def _icu_dateinterval_format(self) -> icu.DateIntervalFormat:
         possible_skeletons = list(_options_to_possible_skeletons(self.options))
-        return icu.DateIntervalFormat.createInstance(possible_skeletons[0], self._icu_locale)  # ty: ignore[unresolved-attribute]
+        return icu.DateIntervalFormat.createInstance(possible_skeletons[0], self.locale._icu_locale)
 
     def format_range(
         self,
         start_datetime: dt.datetime,
         end_datetime: dt.datetime,
     ) -> str:
-        icu_date_interval = icu.DateInterval(start_datetime, end_datetime)  # ty: ignore[unresolved-attribute]
+        icu_date_interval = icu.DateInterval(start_datetime, end_datetime)
         return self._icu_dateinterval_format.format(icu_date_interval)
 
     def format_range_to_parts(
@@ -504,14 +496,14 @@ class DateTimeFormat:
         start_datetime: dt.datetime,
         end_datetime: dt.datetime,
     ) -> Iterable[DateTimeIntervalPatternPart]:
-        icu_date_interval = icu.DateInterval(start_datetime, end_datetime)  # ty: ignore[unresolved-attribute]
+        icu_date_interval = icu.DateInterval(start_datetime, end_datetime)
         formatted = self._icu_dateinterval_format.formatToValue(icu_date_interval)
 
         # Find spans of both datetimes (used to determine which parts have which source)
         span_start = _PartSpan.empty()
         span_end = _PartSpan.empty()
         for part in formatted:
-            if part.getCategory() == icu.UFieldCategory.DATE_INTERVAL_SPAN:  # ty: ignore[unresolved-attribute]
+            if part.getCategory() == icu.UFieldCategory.DATE_INTERVAL_SPAN:
                 match part.getField():
                     case 0:
                         span_start = _PartSpan.from_constrained_fieldposition(part)
@@ -538,7 +530,7 @@ class DateTimeFormat:
                     source=source_of(_PartSpan(start=last_end, end=span.start)),
                 )
 
-            if part.getCategory() == icu.UFieldCategory.DATE:  # ty: ignore[unresolved-attribute]
+            if part.getCategory() == icu.UFieldCategory.DATE:
                 yield DateTimeIntervalPatternPart(
                     type=_PATTERN_FIELD_TO_TYPE.get(part.getField(), "unknown"),
                     value=result_string[span.start:span.end],

python_intl-0.9.0/python_intl/locale.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from functools import cached_property
+
+import icu
+
+
+class Locale:
+    tag: str
+
+    def __init__(self, tag: str) -> None:
+        self.tag = tag
+
+    @cached_property
+    def _icu_locale(self) -> icu.Locale:
+        return icu.Locale(self.tag)

python_intl-0.9.0/python_intl/numberformat.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+import dataclasses
+import decimal
+from functools import cached_property
+from typing import TYPE_CHECKING
+
+import icu
+
+from .locale import Locale
+
+if TYPE_CHECKING:
+    from typing import NotRequired, TypedDict
+
+    from ._types import (
+        CurrencyDisplayT,
+        CurrencySignT,
+        CurrencyT,
+        LocaleMatcherT,
+        StyleT,
+        UnitDisplayT,
+        UnitT,
+    )
+
+    type NumberT = decimal.Decimal | float | int
+
+    # 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 NumberFormatOptionsDictT(TypedDict):
+        locale_matcher: NotRequired[LocaleMatcherT]
+
+        style: NotRequired[StyleT]
+
+        currency: NotRequired[CurrencyT]
+        currency_display: NotRequired[CurrencyDisplayT]
+        currency_sign: NotRequired[CurrencySignT]
+
+        unit: NotRequired[UnitT]
+        unit_display: NotRequired[UnitDisplayT]
+
+
+_CURRENCY_DISPLAY_TO_JSON_MAP: dict[str, str] = {
+    "narrow_symbol": "narrowSymbol",
+}
+
+
+class InvalidNumberFormatOptionError(ValueError):
+    pass
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True, slots=True)
+class NumberFormatOptions:
+    locale_matcher: LocaleMatcherT = "best fit"
+
+    style: StyleT = "decimal"
+
+    currency: CurrencyT | None = None
+    currency_display: CurrencyDisplayT = "symbol"
+    currency_sign: CurrencySignT = "standard"
+
+    unit: UnitT | None = None
+    unit_display: UnitDisplayT = "short"
+
+    def __post_init__(self) -> None:
+        error = None
+        if self.style == "currency" and self.currency is None:
+            error = "You need to provide a currency when using the currency style"
+        elif self.style == "unit" and self.unit is None:
+            error = "You need to provide a unit when using the unit style"
+
+        if error:
+            raise InvalidNumberFormatOptionError(error)
+
+    def to_json(self) -> dict[str, str | int]:
+        return {
+            k: v
+            for k, v in (
+                ("localeMatcher", self.locale_matcher),
+
+                ("style", self.style),
+
+                ("currency", self.currency),
+                ("currencyDisplay", _CURRENCY_DISPLAY_TO_JSON_MAP.get(
+                    self.currency_display,
+                    self.currency_display,
+                )),
+                ("currencySign", self.currency_sign),
+
+                ("unit", self.unit),
+                ("unitDisplay", self.unit_display),
+            )
+            if v is not None
+        }
+
+
+def _options_to_skeleton(options: NumberFormatOptions) -> str:
+    skeleton_parts: list[str] = []
+
+    match options.style:
+        case "decimal":
+            skeleton_parts.append("decimal-auto")
+        case "percent":
+            skeleton_parts.append("precision-integer")
+            skeleton_parts.append("scale/100")
+            skeleton_parts.append("percent")
+        case "currency":
+            skeleton_parts.append(f"currency/{options.currency}")
+            skeleton_parts.append("precision-currency-standard")
+            if options.currency_sign == "accounting":
+                skeleton_parts.append("sign-accounting")
+            match options.currency_display:
+                case "code":
+                    skeleton_parts.append("unit-width-iso-code")
+                case "symbol":
+                    skeleton_parts.append("unit-width-short")
+                case "narrow_symbol":
+                    skeleton_parts.append("unit-width-narrow")
+                case "name":
+                    skeleton_parts.append("unit-width-full-name")
+        case "unit":
+            skeleton_parts.append(f"unit/{options.unit}")
+            match options.unit_display:
+                case "short":
+                    skeleton_parts.append("unit-width-short")
+                case "narrow":
+                    skeleton_parts.append("unit-width-narrow")
+                case "long":
+                    skeleton_parts.append("unit-width-full-name")
+
+    return " ".join(skeleton_parts)
+
+
+class NumberFormat:
+    locale: Locale
+    options: NumberFormatOptions
+
+    def __init__(
+        self,
+        locale: Locale | str,
+        options: NumberFormatOptions | NumberFormatOptionsDictT | None = None,
+    ) -> None:
+        if isinstance(locale, Locale):
+            self.locale = locale
+        else:
+            self.locale = Locale(locale)
+        if options is None:
+            self.options = NumberFormatOptions()
+        elif isinstance(options, NumberFormatOptions):
+            self.options = options
+        else:
+            self.options = NumberFormatOptions(**options)
+
+    @cached_property
+    def _icu_number_formatter(self) -> icu.LocalizedNumberFormatter:
+        skeleton = _options_to_skeleton(self.options)
+        return icu.NumberFormatter.forSkeleton(skeleton).locale(self.locale._icu_locale)
+
+    def format(self, value: NumberT, /) -> str:
+        match value:
+            case int():
+                return self._icu_number_formatter.formatInt(value)
+            case float():
+                return self._icu_number_formatter.formatDouble(value)
+            case decimal.Decimal():
+                return self._icu_number_formatter.formatDecimal(str(value).encode("ascii"))
+
+    @cached_property
+    def _icu_number_range_formatter(self) -> icu.LocalizedNumberRangeFormatter:
+        skeleton = _options_to_skeleton(self.options)
+        return (
+            icu.NumberRangeFormatter
+            .withLocale(self.locale._icu_locale)
+            .numberFormatterBoth(icu.NumberFormatter.forSkeleton(skeleton))
+        )
+
+    def format_range(self, start_value: NumberT, end_value: NumberT, /) -> str:
+        match start_value, end_value:
+            case int(), int():
+                return self._icu_number_range_formatter.formatIntRange(start_value, end_value)
+            case float(), float():
+                return self._icu_number_range_formatter.formatDoubleRange(start_value, end_value)
+            case decimal.Decimal(), decimal.Decimal():
+                return self._icu_number_range_formatter.formatDoubleRange(
+                    # For some reason formatDecimalRange fails, so we fall back to floats
+                    float(start_value),
+                    float(end_value),
+                )
+            case _:
+                error = "Both parameters passed to format_range must have the same type"
+                raise ValueError(error)

python_intl-0.7.1/pyproject.toml.orig

@@ -1,61 +0,0 @@
-[project]
-name = "python-intl"
-version = "0.7.1"
-description = "Python implementation of the Intl JavaScript API"
-readme = "README.md"
-authors = [
-    { name = "David Danier", email = "david.danier@gmail.com" }
-]
-license = "MIT"
-license-files = ["LICENSE"]
-requires-python = ">=3.12"
-dependencies = [
-    "pyicu>=2.16.2",
-]
-
-[project.urls]
-Repository = "https://github.com/ddanier/python-intl"
-
-[dependency-groups]
-dev = [
-    "mypy>=2.3.1",
-    "pyright>=1.1.411",
-    "pytest>=9.1.1",
-    "pytest-cov>=7.1.0",
-    "pytest-xdist>=3.8.0",
-    "ruff>=0.16.3",
-    "tox>=4.60.0",
-    "ty>=0.0.72",
-]
-
-[tool.pytest.ini_options]
-markers = [
-    "unit: mark a test as a unit test",
-    "node: mark tests jun against the node/JS implementation",
-]
-
-[tool.ruff]
-line-length = 115
-target-version = "py312"
-output-format = "grouped"
-
-[tool.ruff.lint]
-select = ["F","E","W","C","I","N","UP","ANN","S","B","A","COM","C4","T20","PT","ARG","TD","RUF"]
-ignore = ["A001","A002","A003","ANN401","C901","N8","B008","F405","F821"]
-
-[tool.ruff.lint.per-file-ignores]
-"__init__.py" = ["F401"]
-"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"
-
-[tool.uv.build-backend]
-module-name = "python_intl"
-module-root = ""

python_intl-0.7.1/python_intl/_types.py

@@ -1,3 +0,0 @@
-from typing import Literal
-
-type LocaleMatcherT = Literal["best fit", "lookup"]