pyxpo-localization 0.1.0a1__tar.gz

pyxpo_localization-0.1.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vishal Chaubey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyxpo_localization-0.1.0a1/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: pyxpo-localization
+Version: 0.1.0a1
+Summary: The device's locales and calendars: the expo-localization API for pyxpo.
+Author: Vishal Chaubey
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pyxpo/pyxpo/tree/main/packages/localization
+Project-URL: Issues, https://github.com/pyxpo/pyxpo/issues
+Keywords: pyxpo,pyxpo-module,mobile,android,ios
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyxpo<0.2,>=0.1.0a2
+Dynamic: license-file
+
+# pyxpo-localization
+
+The user's languages, region formats and calendar settings for [pyxpo](https://github.com/pyxpo/pyxpo)
+apps. The API follows [expo-localization](https://docs.expo.dev/versions/latest/sdk/localization/).
+
+```sh
+pip install pyxpo-localization
+```
+
+```toml
+[tool.pyxpo]
+modules = ["localization"]
+```
+
+```python
+import pyxpo_localization as Localization
+
+locale = Localization.get_locales()[0]
+print(locale.language_tag, locale.region_code, locale.currency_code)   # en-IN IN INR
+cal = Localization.get_calendars()[0]
+print(cal.time_zone, cal.uses_24_hour_clock, cal.first_weekday)        # Asia/Kolkata False 1
+```
+
+Every name also has its expo-localization spelling (`Localization.getLocales`, `Localization.useCalendars`).
+Records accept Expo's camelCase keys too: `locale["languageTag"]`, and `locale.to_dict()` gives the
+camelCase dict.
+
+The values are read once when the app starts. On the desktop they come from `LC_ALL` / `LC_MESSAGES` /
+`LANG` and the system time zone, and the fields the desktop cannot tell (currency, separators) are `None`.
+
+## Functions
+
+| Function | Returns |
+| --- | --- |
+| `get_locales()` | `list[Locale]`, the preferred languages, most preferred first. Never empty. |
+| `get_calendars()` | `list[Calendar]`, the user's calendars, preferred first. Never empty. |
+| `use_locales()`, `use_calendars()` | The same, for use in components. |
+
+## `Locale`
+
+| Field | Example | Notes |
+| --- | --- | --- |
+| `language_tag` | `"en-IN"` | BCP 47 tag. |
+| `language_code` | `"en"` | |
+| `language_script_code` | `"Hant"` | `None` when the tag has no script. |
+| `region_code` | `"IN"` | iOS: the region setting. Android: the locale's region. |
+| `language_region_code` | `"IN"` | The region in the language tag. |
+| `currency_code`, `currency_symbol` | `"INR"`, `"₹"` | iOS: from the region setting. |
+| `language_currency_code`, `language_currency_symbol` | `"INR"`, `"₹"` | From the language tag's region. |
+| `decimal_separator`, `digit_grouping_separator` | `"."`, `","` | |
+| `text_direction` | `"ltr"` | `"ltr"` or `"rtl"`. |
+| `measurement_system` | `"metric"` | `"metric"`, `"us"` or `"uk"`. |
+| `temperature_unit` | `"celsius"` | `"celsius"` or `"fahrenheit"`. Follows the user's setting on iOS 16+ and Android 14+. |
+
+## `Calendar`
+
+| Field | Example | Notes |
+| --- | --- | --- |
+| `calendar` | `"gregory"` | CLDR name, as in JavaScript `Intl`. |
+| `time_zone` | `"Asia/Kolkata"` | IANA id. |
+| `uses_24_hour_clock` | `False` | |
+| `first_weekday` | `1` | 1 is Sunday, 7 is Saturday. |
+
+## Platforms
+
+iOS 15+, Android 7 (API 24)+. No permissions.

pyxpo_localization-0.1.0a1/README.md

@@ -0,0 +1,66 @@
+# pyxpo-localization
+
+The user's languages, region formats and calendar settings for [pyxpo](https://github.com/pyxpo/pyxpo)
+apps. The API follows [expo-localization](https://docs.expo.dev/versions/latest/sdk/localization/).
+
+```sh
+pip install pyxpo-localization
+```
+
+```toml
+[tool.pyxpo]
+modules = ["localization"]
+```
+
+```python
+import pyxpo_localization as Localization
+
+locale = Localization.get_locales()[0]
+print(locale.language_tag, locale.region_code, locale.currency_code)   # en-IN IN INR
+cal = Localization.get_calendars()[0]
+print(cal.time_zone, cal.uses_24_hour_clock, cal.first_weekday)        # Asia/Kolkata False 1
+```
+
+Every name also has its expo-localization spelling (`Localization.getLocales`, `Localization.useCalendars`).
+Records accept Expo's camelCase keys too: `locale["languageTag"]`, and `locale.to_dict()` gives the
+camelCase dict.
+
+The values are read once when the app starts. On the desktop they come from `LC_ALL` / `LC_MESSAGES` /
+`LANG` and the system time zone, and the fields the desktop cannot tell (currency, separators) are `None`.
+
+## Functions
+
+| Function | Returns |
+| --- | --- |
+| `get_locales()` | `list[Locale]`, the preferred languages, most preferred first. Never empty. |
+| `get_calendars()` | `list[Calendar]`, the user's calendars, preferred first. Never empty. |
+| `use_locales()`, `use_calendars()` | The same, for use in components. |
+
+## `Locale`
+
+| Field | Example | Notes |
+| --- | --- | --- |
+| `language_tag` | `"en-IN"` | BCP 47 tag. |
+| `language_code` | `"en"` | |
+| `language_script_code` | `"Hant"` | `None` when the tag has no script. |
+| `region_code` | `"IN"` | iOS: the region setting. Android: the locale's region. |
+| `language_region_code` | `"IN"` | The region in the language tag. |
+| `currency_code`, `currency_symbol` | `"INR"`, `"₹"` | iOS: from the region setting. |
+| `language_currency_code`, `language_currency_symbol` | `"INR"`, `"₹"` | From the language tag's region. |
+| `decimal_separator`, `digit_grouping_separator` | `"."`, `","` | |
+| `text_direction` | `"ltr"` | `"ltr"` or `"rtl"`. |
+| `measurement_system` | `"metric"` | `"metric"`, `"us"` or `"uk"`. |
+| `temperature_unit` | `"celsius"` | `"celsius"` or `"fahrenheit"`. Follows the user's setting on iOS 16+ and Android 14+. |
+
+## `Calendar`
+
+| Field | Example | Notes |
+| --- | --- | --- |
+| `calendar` | `"gregory"` | CLDR name, as in JavaScript `Intl`. |
+| `time_zone` | `"Asia/Kolkata"` | IANA id. |
+| `uses_24_hour_clock` | `False` | |
+| `first_weekday` | `1` | 1 is Sunday, 7 is Saturday. |
+
+## Platforms
+
+iOS 15+, Android 7 (API 24)+. No permissions.

pyxpo_localization-0.1.0a1/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyxpo-localization"
+dynamic = ["version"]
+description = "The device's locales and calendars: the expo-localization API for pyxpo."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Vishal Chaubey" }]
+keywords = ["pyxpo", "pyxpo-module", "mobile", "android", "ios"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: User Interfaces",
+]
+requires-python = ">=3.9"
+dependencies = ["pyxpo>=0.1.0a2,<0.2"]
+
+[project.urls]
+Homepage = "https://github.com/pyxpo/pyxpo/tree/main/packages/localization"
+Issues = "https://github.com/pyxpo/pyxpo/issues"
+
+# How `pyxpo build` finds this module: the entry point name is the module name apps list in
+# `[tool.pyxpo] modules`, its value the import package holding pyxpo-module.json.
+[project.entry-points."pyxpo.modules"]
+localization = "pyxpo_localization"
+
+[tool.setuptools]
+packages = ["pyxpo_localization"]
+
+[tool.setuptools.dynamic]
+version = { attr = "pyxpo_localization.__version__" }
+
+[tool.setuptools.package-data]
+pyxpo_localization = ["pyxpo-module.json", "py.typed", "ios/**/*", "android/**/*"]
+
+[tool.setuptools.exclude-package-data]
+"*" = ["__pycache__", "*.pyc", ".DS_Store"]

pyxpo_localization-0.1.0a1/pyxpo_localization/__init__.py

@@ -0,0 +1,169 @@
+"""The device's language, region and calendar settings: the expo-localization API.
+
+    import pyxpo_localization as Localization
+
+    locale = Localization.get_locales()[0]          # or Localization.getLocales()
+    locale.language_code, locale.region_code         # "en", "US"
+    locale["languageTag"]                            # camelCase keys work too: "en-US"
+    cal = Localization.get_calendars()[0]
+    cal.time_zone, cal.uses_24_hour_clock            # "Europe/Berlin", True
+
+The values are read once when the app starts. On the desktop they come from the `LANG`/`LC_*` environment
+and the system time zone; fields the desktop cannot tell are None.
+"""
+from __future__ import annotations
+
+import os
+import time
+from dataclasses import dataclass, fields
+from typing import Any, Dict, List, Optional
+
+from pyxpo.module_api import constants, platform, require_linked
+
+__version__ = "0.1.0a1"
+
+
+class _Record:
+    """Attribute access in snake_case, item access in Expo's camelCase."""
+    _CAMEL: Dict[str, str] = {}
+
+    def __getitem__(self, key: str) -> Any:
+        name = self._CAMEL.get(key, key)
+        if name not in {f.name for f in fields(self)}:  # type: ignore[arg-type]
+            raise KeyError(key)
+        return getattr(self, name)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """The record with Expo's camelCase keys."""
+        return {camel: getattr(self, snake) for camel, snake in self._CAMEL.items()}
+
+
+@dataclass(frozen=True)
+class Locale(_Record):
+    """One preferred language, with the formatting rules of the user's region."""
+    language_tag: str
+    language_code: Optional[str] = None
+    language_script_code: Optional[str] = None
+    region_code: Optional[str] = None
+    language_region_code: Optional[str] = None
+    currency_code: Optional[str] = None
+    currency_symbol: Optional[str] = None
+    language_currency_code: Optional[str] = None
+    language_currency_symbol: Optional[str] = None
+    decimal_separator: Optional[str] = None
+    digit_grouping_separator: Optional[str] = None
+    text_direction: Optional[str] = None
+    measurement_system: Optional[str] = None
+    temperature_unit: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class Calendar(_Record):
+    """One calendar the user has set: its type, time zone, clock style and first weekday."""
+    calendar: Optional[str] = None
+    time_zone: Optional[str] = None
+    uses_24_hour_clock: Optional[bool] = None
+    first_weekday: Optional[int] = None
+
+
+Locale._CAMEL = {
+    "languageTag": "language_tag", "languageCode": "language_code", "languageScriptCode": "language_script_code",
+    "regionCode": "region_code", "languageRegionCode": "language_region_code", "currencyCode": "currency_code",
+    "currencySymbol": "currency_symbol", "languageCurrencyCode": "language_currency_code",
+    "languageCurrencySymbol": "language_currency_symbol", "decimalSeparator": "decimal_separator",
+    "digitGroupingSeparator": "digit_grouping_separator", "textDirection": "text_direction",
+    "measurementSystem": "measurement_system", "temperatureUnit": "temperature_unit",
+}
+Calendar._CAMEL = {
+    "calendar": "calendar", "timeZone": "time_zone", "uses24hourClock": "uses_24_hour_clock",
+    "firstWeekday": "first_weekday",
+}
+
+# Regions that use Fahrenheit and US units (CLDR). The desktop has no other source for these.
+_FAHRENHEIT = {"US", "BS", "BZ", "KY", "PR", "PW", "LR", "FM", "MH"}
+_US_UNITS = {"US", "LR", "MM"}
+_RTL = {"ar", "arc", "ckb", "dv", "fa", "ha", "he", "iw", "khw", "ks", "ku", "ps", "sd", "ur", "yi"}
+
+
+def _from_native(cls: Any, raw: Dict[str, Any]) -> Any:
+    return cls(**{snake: raw.get(camel) for camel, snake in cls._CAMEL.items()})
+
+
+def _native(key: str) -> Optional[List[Dict[str, Any]]]:
+    if platform() == "desktop":
+        return None
+    require_linked("Localization", "localization", package="pyxpo-localization")
+    return list(constants("Localization").get(key) or [])
+
+
+def _desktop_locale() -> Locale:
+    raw = ""
+    for var in ("LC_ALL", "LC_MESSAGES", "LANG"):
+        raw = os.environ.get(var, "")
+        if raw:
+            break
+    raw = raw.split(".")[0].split("@")[0]
+    if not raw or raw in ("C", "POSIX"):
+        raw = "en_US"
+    parts = raw.replace("-", "_").split("_")
+    lang = parts[0].lower()
+    script = next((p.title() for p in parts[1:] if len(p) == 4), None)
+    region = next((p.upper() for p in parts[1:] if (len(p) == 2 and p.isalpha()) or (len(p) == 3 and p.isdigit())), None)
+    tag = "-".join(p for p in (lang, script, region) if p)
+    return Locale(
+        language_tag=tag, language_code=lang, language_script_code=script, region_code=region,
+        language_region_code=region, text_direction="rtl" if lang in _RTL else "ltr",
+        measurement_system=None if region is None else "us" if region in _US_UNITS else "uk" if region == "GB" else "metric",
+        temperature_unit=None if region is None else "fahrenheit" if region in _FAHRENHEIT else "celsius",
+    )
+
+
+def _desktop_time_zone() -> Optional[str]:
+    tz = os.environ.get("TZ", "").lstrip(":")
+    if "/" in tz and not tz.startswith("/"):
+        return tz
+    try:
+        target = os.path.realpath("/etc/localtime")
+    except OSError:
+        return None
+    marker = "zoneinfo/"
+    return target.split(marker, 1)[1] if marker in target else (time.tzname[0] or None)
+
+
+def get_locales() -> List[Locale]:
+    """The user's preferred languages, most preferred first. Always at least one entry."""
+    raw = _native("locales")
+    if raw is None:
+        return [_desktop_locale()]
+    out = [_from_native(Locale, r) for r in raw]
+    return out or [Locale(language_tag="en-US", language_code="en", region_code="US", language_region_code="US")]
+
+
+def get_calendars() -> List[Calendar]:
+    """The user's calendars, preferred first. Always at least one entry."""
+    raw = _native("calendars")
+    if raw is None:
+        return [Calendar(calendar="gregory", time_zone=_desktop_time_zone())]
+    out = [_from_native(Calendar, r) for r in raw]
+    return out or [Calendar(calendar="gregory")]
+
+
+def use_locales() -> List[Locale]:
+    """Hook form of `get_locales()`. The values do not change while the app runs."""
+    return get_locales()
+
+
+def use_calendars() -> List[Calendar]:
+    """Hook form of `get_calendars()`. The values do not change while the app runs."""
+    return get_calendars()
+
+
+getLocales = get_locales
+getCalendars = get_calendars
+useLocales = use_locales
+useCalendars = use_calendars
+
+__all__ = [
+    "Locale", "Calendar", "get_locales", "get_calendars", "use_locales", "use_calendars",
+    "getLocales", "getCalendars", "useLocales", "useCalendars",
+]

pyxpo_localization-0.1.0a1/pyxpo_localization/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

pyxpo_localization-0.1.0a1/pyxpo_localization/android/src/main/java/dev/pyxpo/modules/localization/LocalizationModule.kt

@@ -0,0 +1,89 @@
+package dev.pyxpo.modules.localization
+
+import android.content.Context
+import android.os.Build
+import android.os.LocaleList
+import android.text.TextUtils
+import android.text.format.DateFormat
+import android.util.LayoutDirection
+import dev.pyxpo.moduleapi.PxModule
+import dev.pyxpo.moduleapi.PxModuleContext
+import dev.pyxpo.moduleapi.PxReply
+import org.json.JSONArray
+import java.text.DecimalFormatSymbols
+import java.util.Currency
+import java.util.Locale
+import java.util.TimeZone
+
+/** expo-localization on Android: `LocaleList`, `DecimalFormatSymbols`, `Currency` and the ICU calendar. */
+class LocalizationModule : PxModule() {
+    override val name = "Localization"
+
+    override fun constants(context: Context): Map<String, Any?> =
+        mapOf("locales" to locales(), "calendars" to listOf(calendar(context)))
+
+    private fun currency(l: Locale): Currency? = try { Currency.getInstance(l) } catch (_: Exception) { null }
+
+    private fun measurementSystem(l: Locale): String? {
+        if (l.country.isEmpty()) return null
+        if (Build.VERSION.SDK_INT >= 28) {
+            return when (android.icu.util.LocaleData.getMeasurementSystem(android.icu.util.ULocale.forLocale(l))) {
+                android.icu.util.LocaleData.MeasurementSystem.US -> "us"
+                android.icu.util.LocaleData.MeasurementSystem.UK -> "uk"
+                else -> "metric"
+            }
+        }
+        return when (l.country) { "US", "LR", "MM" -> "us"; "GB" -> "uk"; else -> "metric" }
+    }
+
+    /** Android 14+ lets the user pick the unit (`-u-mu-` locale extension); else the region's CLDR default. */
+    private fun temperatureUnit(l: Locale): String? {
+        when (l.getUnicodeLocaleType("mu")) {
+            "celsius" -> return "celsius"
+            "fahrenhe" -> return "fahrenheit"
+        }
+        if (l.country.isEmpty()) return null
+        return when (l.country) { "US", "BS", "BZ", "KY", "PR", "PW", "LR", "FM", "MH" -> "fahrenheit"; else -> "celsius" }
+    }
+
+    private fun locales(): List<Map<String, Any?>> {
+        val list = LocaleList.getDefault()
+        return (0 until list.size()).map { i ->
+            val l = list[i]
+            val cur = currency(l)
+            val sym = DecimalFormatSymbols.getInstance(l)
+            val region = l.country.ifEmpty { null }
+            mapOf(
+                "languageTag" to l.toLanguageTag(),
+                "languageCode" to l.language.ifEmpty { null },
+                "languageScriptCode" to l.script.ifEmpty { null },
+                "regionCode" to region,
+                "languageRegionCode" to region,
+                "currencyCode" to cur?.currencyCode,
+                "currencySymbol" to cur?.getSymbol(l),
+                "languageCurrencyCode" to cur?.currencyCode,
+                "languageCurrencySymbol" to cur?.getSymbol(l),
+                "decimalSeparator" to sym.decimalSeparator.toString(),
+                "digitGroupingSeparator" to sym.groupingSeparator.toString(),
+                "textDirection" to if (TextUtils.getLayoutDirectionFromLocale(l) == LayoutDirection.RTL) "rtl" else "ltr",
+                "measurementSystem" to measurementSystem(l),
+                "temperatureUnit" to temperatureUnit(l),
+            )
+        }
+    }
+
+    private fun calendar(c: Context): Map<String, Any?> {
+        val cal = android.icu.util.Calendar.getInstance()
+        val type = cal.type.let { if (it == "gregorian") "gregory" else it }
+        return mapOf(
+            "calendar" to type,
+            "timeZone" to TimeZone.getDefault().id,
+            "uses24hourClock" to DateFormat.is24HourFormat(c),
+            "firstWeekday" to cal.firstDayOfWeek,
+        )
+    }
+
+    override fun call(ctx: PxModuleContext, method: String, args: JSONArray, reply: PxReply) {
+        reply(null, "Localization has no method '$method'")
+    }
+}

pyxpo_localization-0.1.0a1/pyxpo_localization/ios/LocalizationModule.swift

@@ -0,0 +1,98 @@
+import Foundation
+
+/// expo-localization on iOS. Language fields come from each preferred language; region, currency and
+/// number formats come from the user's region setting (`Locale.current`), as in Settings.
+final class LocalizationModule: PxModule {
+    static let moduleName = "Localization"
+
+    required init() {}
+
+    static var constants: [String: Any] {
+        ["locales": locales, "calendars": [calendar]]
+    }
+
+    private static func value(_ s: String?) -> Any { s ?? NSNull() }
+
+    private static func measurementSystem(_ l: Locale) -> String {
+        if #available(iOS 16, *) {
+            switch l.measurementSystem {
+            case .us: return "us"
+            case .uk: return "uk"
+            default: return "metric"
+            }
+        }
+        return l.usesMetricSystem ? "metric" : "us"
+    }
+
+    /// The unit `MeasurementFormatter` picks for the locale (follows the Temperature setting on iOS 16+).
+    private static func temperatureUnit(_ l: Locale) -> String {
+        let f = MeasurementFormatter()
+        f.locale = l
+        f.numberFormatter.maximumFractionDigits = 0
+        let text = f.string(from: Measurement(value: 0, unit: UnitTemperature.celsius))
+        return text.contains("F") ? "fahrenheit" : "celsius"
+    }
+
+    private static var locales: [[String: Any]] {
+        let current = Locale.current
+        let tags = Locale.preferredLanguages.isEmpty ? [current.identifier] : Locale.preferredLanguages
+        return tags.map { tag in
+            let l = Locale(identifier: tag)
+            let lang = l.languageCode
+            return [
+                "languageTag": tag,
+                "languageCode": value(lang),
+                "languageScriptCode": value(l.scriptCode),
+                "regionCode": value(current.regionCode),
+                "languageRegionCode": value(l.regionCode),
+                "currencyCode": value(current.currencyCode),
+                "currencySymbol": value(current.currencySymbol),
+                "languageCurrencyCode": value(l.currencyCode),
+                "languageCurrencySymbol": value(l.currencySymbol),
+                "decimalSeparator": value(current.decimalSeparator),
+                "digitGroupingSeparator": value(current.groupingSeparator),
+                "textDirection": lang.map { Locale.characterDirection(forLanguage: $0) == .rightToLeft ? "rtl" : "ltr" } ?? NSNull(),
+                "measurementSystem": measurementSystem(current),
+                "temperatureUnit": temperatureUnit(current),
+            ]
+        }
+    }
+
+    /// CLDR names for the calendar identifiers, as on the web (`Intl`).
+    private static func cldr(_ id: Calendar.Identifier) -> String {
+        switch id {
+        case .gregorian: return "gregory"
+        case .buddhist: return "buddhist"
+        case .chinese: return "chinese"
+        case .coptic: return "coptic"
+        case .ethiopicAmeteMihret: return "ethiopic"
+        case .ethiopicAmeteAlem: return "ethioaa"
+        case .hebrew: return "hebrew"
+        case .indian: return "indian"
+        case .islamic: return "islamic"
+        case .islamicCivil: return "islamic-civil"
+        case .islamicTabular: return "islamic-tbla"
+        case .islamicUmmAlQura: return "islamic-umalqura"
+        case .iso8601: return "iso8601"
+        case .japanese: return "japanese"
+        case .persian: return "persian"
+        case .republicOfChina: return "roc"
+        default: return "gregory"
+        }
+    }
+
+    private static var calendar: [String: Any] {
+        let cal = Calendar.current
+        let hourFormat = DateFormatter.dateFormat(fromTemplate: "j", options: 0, locale: Locale.current) ?? ""
+        return [
+            "calendar": cldr(cal.identifier),
+            "timeZone": TimeZone.current.identifier,
+            "uses24hourClock": !hourFormat.contains("a"),
+            "firstWeekday": cal.firstWeekday,
+        ]
+    }
+
+    func call(_ ctx: PxModuleContext, _ method: String, _ args: [Any], _ reply: @escaping PxReply) {
+        reply(nil, "Localization has no method '\(method)'")
+    }
+}

pyxpo_localization-0.1.0a1/pyxpo_localization/pyxpo-module.json

@@ -0,0 +1,14 @@
+{
+  "schemaVersion": 1,
+  "nativeContract": 2,
+  "name": "localization",
+  "native": "Localization",
+  "ios": {
+    "classes": ["LocalizationModule"]
+  },
+  "android": {
+    "namespace": "dev.pyxpo.modules.localization",
+    "classes": ["dev.pyxpo.modules.localization.LocalizationModule"],
+    "minSdk": 24
+  }
+}

pyxpo_localization-0.1.0a1/pyxpo_localization.egg-info/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: pyxpo-localization
+Version: 0.1.0a1
+Summary: The device's locales and calendars: the expo-localization API for pyxpo.
+Author: Vishal Chaubey
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pyxpo/pyxpo/tree/main/packages/localization
+Project-URL: Issues, https://github.com/pyxpo/pyxpo/issues
+Keywords: pyxpo,pyxpo-module,mobile,android,ios
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyxpo<0.2,>=0.1.0a2
+Dynamic: license-file
+
+# pyxpo-localization
+
+The user's languages, region formats and calendar settings for [pyxpo](https://github.com/pyxpo/pyxpo)
+apps. The API follows [expo-localization](https://docs.expo.dev/versions/latest/sdk/localization/).
+
+```sh
+pip install pyxpo-localization
+```
+
+```toml
+[tool.pyxpo]
+modules = ["localization"]
+```
+
+```python
+import pyxpo_localization as Localization
+
+locale = Localization.get_locales()[0]
+print(locale.language_tag, locale.region_code, locale.currency_code)   # en-IN IN INR
+cal = Localization.get_calendars()[0]
+print(cal.time_zone, cal.uses_24_hour_clock, cal.first_weekday)        # Asia/Kolkata False 1
+```
+
+Every name also has its expo-localization spelling (`Localization.getLocales`, `Localization.useCalendars`).
+Records accept Expo's camelCase keys too: `locale["languageTag"]`, and `locale.to_dict()` gives the
+camelCase dict.
+
+The values are read once when the app starts. On the desktop they come from `LC_ALL` / `LC_MESSAGES` /
+`LANG` and the system time zone, and the fields the desktop cannot tell (currency, separators) are `None`.
+
+## Functions
+
+| Function | Returns |
+| --- | --- |
+| `get_locales()` | `list[Locale]`, the preferred languages, most preferred first. Never empty. |
+| `get_calendars()` | `list[Calendar]`, the user's calendars, preferred first. Never empty. |
+| `use_locales()`, `use_calendars()` | The same, for use in components. |
+
+## `Locale`
+
+| Field | Example | Notes |
+| --- | --- | --- |
+| `language_tag` | `"en-IN"` | BCP 47 tag. |
+| `language_code` | `"en"` | |
+| `language_script_code` | `"Hant"` | `None` when the tag has no script. |
+| `region_code` | `"IN"` | iOS: the region setting. Android: the locale's region. |
+| `language_region_code` | `"IN"` | The region in the language tag. |
+| `currency_code`, `currency_symbol` | `"INR"`, `"₹"` | iOS: from the region setting. |
+| `language_currency_code`, `language_currency_symbol` | `"INR"`, `"₹"` | From the language tag's region. |
+| `decimal_separator`, `digit_grouping_separator` | `"."`, `","` | |
+| `text_direction` | `"ltr"` | `"ltr"` or `"rtl"`. |
+| `measurement_system` | `"metric"` | `"metric"`, `"us"` or `"uk"`. |
+| `temperature_unit` | `"celsius"` | `"celsius"` or `"fahrenheit"`. Follows the user's setting on iOS 16+ and Android 14+. |
+
+## `Calendar`
+
+| Field | Example | Notes |
+| --- | --- | --- |
+| `calendar` | `"gregory"` | CLDR name, as in JavaScript `Intl`. |
+| `time_zone` | `"Asia/Kolkata"` | IANA id. |
+| `uses_24_hour_clock` | `False` | |
+| `first_weekday` | `1` | 1 is Sunday, 7 is Saturday. |
+
+## Platforms
+
+iOS 15+, Android 7 (API 24)+. No permissions.

pyxpo_localization-0.1.0a1/pyxpo_localization.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+pyxpo_localization/__init__.py
+pyxpo_localization/py.typed
+pyxpo_localization/pyxpo-module.json
+pyxpo_localization.egg-info/PKG-INFO
+pyxpo_localization.egg-info/SOURCES.txt
+pyxpo_localization.egg-info/dependency_links.txt
+pyxpo_localization.egg-info/entry_points.txt
+pyxpo_localization.egg-info/requires.txt
+pyxpo_localization.egg-info/top_level.txt
+pyxpo_localization/android/src/main/AndroidManifest.xml
+pyxpo_localization/android/src/main/java/dev/pyxpo/modules/localization/LocalizationModule.kt
+pyxpo_localization/ios/LocalizationModule.swift

pyxpo_localization-0.1.0a1/pyxpo_localization.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyxpo_localization-0.1.0a1/pyxpo_localization.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pyxpo.modules]
+localization = pyxpo_localization

pyxpo_localization-0.1.0a1/pyxpo_localization.egg-info/requires.txt

@@ -0,0 +1 @@
+pyxpo<0.2,>=0.1.0a2

pyxpo_localization-0.1.0a1/pyxpo_localization.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyxpo_localization

pyxpo_localization-0.1.0a1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+