djalaali 0.1.0__tar.gz

djalaali-0.1.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: djalaali
+Version: 0.1.0
+Summary: Jalali (Persian) calendar support for Django
+License: MIT
+Keywords: django,jalali,persian,calendar,jdate
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Internationalization
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: Django>=4.2
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-xdist; extra == "dev"
+
+# djalaali
+
+Jalali (Persian) calendar support for Django: `jdate` and `jdatetime` types,
+model and form fields, and template tags.
+
+## Install
+
+```sh
+pip install djalaali
+```
+
+Add `"djalaali"` to `INSTALLED_APPS`.
+
+## Usage
+
+```python
+from djalaali.jdate import jdate
+
+d = jdate(1403, 1, 1)
+```
+
+## Development
+
+```sh
+make install
+make test
+```
+
+## License
+
+MIT

djalaali-0.1.0/README.md

@@ -0,0 +1,31 @@
+# djalaali
+
+Jalali (Persian) calendar support for Django: `jdate` and `jdatetime` types,
+model and form fields, and template tags.
+
+## Install
+
+```sh
+pip install djalaali
+```
+
+Add `"djalaali"` to `INSTALLED_APPS`.
+
+## Usage
+
+```python
+from djalaali.jdate import jdate
+
+d = jdate(1403, 1, 1)
+```
+
+## Development
+
+```sh
+make install
+make test
+```
+
+## License
+
+MIT

djalaali-0.1.0/djalaali/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

djalaali-0.1.0/djalaali/_calgo.c

@@ -0,0 +1,336 @@
+/*
+ * C implementation of the Jalaali conversion algorithm in djalaali/algo.py.
+ *
+ * Ported from https://github.com/jalaali/go-jalaali
+ *
+ * Built against the stable ABI (abi3), so a single wheel per platform serves
+ * every supported Python version. C integer division and remainder truncate
+ * toward zero, exactly like Go's, so the formulas are copied verbatim.
+ *
+ * Arguments that do not fit comfortably in 64-bit arithmetic are handed to
+ * the pure-Python implementation registered through setup(), which keeps
+ * the behaviour (including exceptions) identical for every input.
+ */
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <stdint.h>
+
+#define N_BREAKS 20
+#define MAX_ARG 1000000000000LL /* keeps every intermediate within int64 */
+
+static const int64_t BREAKS[N_BREAKS] = {
+    -61,  9,    38,   199,  426,  686,  756,  818,  1111, 1181,
+    1210, 1635, 2060, 2097, 2192, 2262, 2324, 2394, 2456, 3178,
+};
+
+static PyObject *error_type = NULL;
+static PyObject *py_to_jalaali = NULL;
+static PyObject *py_to_gregorian = NULL;
+static PyObject *py_is_leap_year = NULL;
+static PyObject *py_month_length = NULL;
+
+/* Returns 0 on success, -1 with an exception set, 1 if too large for C. */
+static int
+get_arg(PyObject *obj, int64_t *out)
+{
+    int overflow = 0;
+    long long v = PyLong_AsLongLongAndOverflow(obj, &overflow);
+    if (v == -1 && PyErr_Occurred()) {
+        return -1;
+    }
+    if (overflow || v > MAX_ARG || v < -MAX_ARG) {
+        return 1;
+    }
+    *out = v;
+    return 0;
+}
+
+static int
+get_args(PyObject *args, int n, int64_t *out)
+{
+    if (PyTuple_Size(args) != n) {
+        PyErr_Format(PyExc_TypeError, "expected %d arguments, got %zd", n,
+                     PyTuple_Size(args));
+        return -1;
+    }
+    int too_big = 0;
+    for (int i = 0; i < n; i++) {
+        int r = get_arg(PyTuple_GetItem(args, i), &out[i]);
+        if (r < 0) {
+            return -1;
+        }
+        too_big |= r;
+    }
+    return too_big;
+}
+
+static void
+raise_invalid_year(int64_t year)
+{
+    PyObject *exc = PyObject_CallFunction(error_type, "L", (long long)year);
+    if (exc != NULL) {
+        PyErr_SetObject(error_type, exc);
+        Py_DECREF(exc);
+    }
+}
+
+/* Returns 0 on success, -1 (without an exception set) for an invalid year. */
+static int
+jal_cal(int64_t jy, int64_t *leap, int64_t *gy, int64_t *march)
+{
+    int64_t g = jy + 621;
+    int64_t leap_j = -14;
+    int64_t jp = BREAKS[0];
+    int64_t jump = 0;
+
+    if (jy < jp || jy >= BREAKS[N_BREAKS - 1]) {
+        return -1;
+    }
+
+    for (int i = 1; i < N_BREAKS; i++) {
+        int64_t jm = BREAKS[i];
+        jump = jm - jp;
+        if (jy < jm) {
+            break;
+        }
+        leap_j += (jump / 33) * 8 + (jump % 33) / 4;
+        jp = jm;
+    }
+
+    int64_t n = jy - jp;
+    leap_j += (n / 33) * 8 + (n % 33 + 3) / 4;
+    if (jump % 33 == 4 && jump - n == 4) {
+        leap_j += 1;
+    }
+
+    int64_t leap_g = g / 4 - ((g / 100 + 1) * 3) / 4 - 150;
+
+    if (jump - n < 6) {
+        n = n - jump + ((jump + 4) / 33) * 33;
+    }
+
+    int64_t l = ((n + 1) % 33 - 1) % 4;
+    if (l == -1) {
+        l = 4;
+    }
+
+    *leap = l;
+    *gy = g;
+    *march = 20 + leap_j - leap_g;
+    return 0;
+}
+
+static int64_t
+g2d(int64_t gy, int64_t gm, int64_t gd)
+{
+    int64_t d = ((gy + (gm - 8) / 6 + 100100) * 1461) / 4 +
+                (153 * ((gm + 9) % 12) + 2) / 5 + gd - 34840408;
+    d = d - (((gy + 100100 + (gm - 8) / 6) / 100) * 3) / 4 + 752;
+    return d;
+}
+
+static void
+d2g(int64_t jdn, int64_t *gy, int64_t *gm, int64_t *gd)
+{
+    int64_t j = 4 * jdn + 139361631;
+    j = j + (((4 * jdn + 183187720) / 146097) * 3) / 4 * 4 - 3908;
+    int64_t i = ((j % 1461) / 4) * 5 + 308;
+    *gd = (i % 153) / 5 + 1;
+    *gm = (i / 153) % 12 + 1;
+    *gy = j / 1461 - 100100 + (8 - *gm) / 6;
+}
+
+static int64_t
+month_len(int64_t jy, int64_t jm, int *err)
+{
+    *err = 0;
+    if (jm <= 6) {
+        return 31;
+    }
+    if (jm <= 11) {
+        return 30;
+    }
+    int64_t leap, gy, march;
+    if (jal_cal(jy, &leap, &gy, &march) < 0) {
+        *err = 1;
+        return 0;
+    }
+    return leap == 0 ? 30 : 29;
+}
+
+static PyObject *
+fallback(PyObject *func, PyObject *args)
+{
+    return PyObject_CallObject(func, args);
+}
+
+static PyObject *
+calgo_to_jalaali(PyObject *self, PyObject *args)
+{
+    int64_t a[3];
+    int r = get_args(args, 3, a);
+    if (r < 0) {
+        return NULL;
+    }
+    if (r > 0) {
+        return fallback(py_to_jalaali, args);
+    }
+
+    int64_t gy, gm, gd;
+    int64_t jdn = g2d(a[0], a[1], a[2]);
+    d2g(jdn, &gy, &gm, &gd);
+
+    int64_t jy = gy - 621;
+    int64_t leap, g, march;
+    if (jal_cal(jy, &leap, &g, &march) < 0) {
+        raise_invalid_year(jy);
+        return NULL;
+    }
+    int64_t k = jdn - g2d(gy, 3, march);
+    int64_t jm, jd;
+    if (k >= 0) {
+        if (k <= 185) {
+            return Py_BuildValue("(LLL)", (long long)jy,
+                                 (long long)(1 + k / 31),
+                                 (long long)(k % 31 + 1));
+        }
+        k -= 186;
+    }
+    else {
+        jy -= 1;
+        k += 179;
+        if (leap == 1) {
+            k += 1;
+        }
+    }
+    jm = 7 + k / 30;
+    jd = k % 30 + 1;
+    return Py_BuildValue("(LLL)", (long long)jy, (long long)jm,
+                         (long long)jd);
+}
+
+static PyObject *
+calgo_to_gregorian(PyObject *self, PyObject *args)
+{
+    int64_t a[3];
+    int r = get_args(args, 3, a);
+    if (r < 0) {
+        return NULL;
+    }
+    if (r > 0) {
+        return fallback(py_to_gregorian, args);
+    }
+    int64_t jy = a[0], jm = a[1], jd = a[2];
+
+    int valid = !(jy < -61 || jy > 3177 || jm < 1 || jm > 12 || jd < 1);
+    if (valid) {
+        int err;
+        valid = jd <= month_len(jy, jm, &err);
+    }
+    if (!valid) {
+        return PyErr_Format(
+            PyExc_ValueError,
+            "invalid jalaali date: year=%lld, month=%lld, day=%lld",
+            (long long)jy, (long long)jm, (long long)jd);
+    }
+
+    int64_t leap, gy, march;
+    if (jal_cal(jy, &leap, &gy, &march) < 0) {
+        raise_invalid_year(jy);
+        return NULL;
+    }
+    int64_t jm7 = jm / 7;
+    int64_t jdn = g2d(gy, 3, march) + (jm - 1) * 31 - jm7 * (jm - 7) + jd - 1;
+    int64_t y, m, d;
+    d2g(jdn, &y, &m, &d);
+    return Py_BuildValue("(LLL)", (long long)y, (long long)m, (long long)d);
+}
+
+static PyObject *
+calgo_is_leap_year(PyObject *self, PyObject *args)
+{
+    int64_t a[1];
+    int r = get_args(args, 1, a);
+    if (r < 0) {
+        return NULL;
+    }
+    if (r > 0) {
+        return fallback(py_is_leap_year, args);
+    }
+    int64_t leap, gy, march;
+    if (jal_cal(a[0], &leap, &gy, &march) < 0) {
+        raise_invalid_year(a[0]);
+        return NULL;
+    }
+    return PyBool_FromLong(leap == 0);
+}
+
+static PyObject *
+calgo_month_length(PyObject *self, PyObject *args)
+{
+    int64_t a[2];
+    int r = get_args(args, 2, a);
+    if (r < 0) {
+        return NULL;
+    }
+    if (r > 0) {
+        return fallback(py_month_length, args);
+    }
+    int err;
+    int64_t n = month_len(a[0], a[1], &err);
+    if (err) {
+        raise_invalid_year(a[0]);
+        return NULL;
+    }
+    return PyLong_FromLongLong(n);
+}
+
+static PyObject *
+calgo_setup(PyObject *self, PyObject *args)
+{
+    PyObject *e, *a, *b, *c, *d;
+    if (!PyArg_ParseTuple(args, "OOOOO", &e, &a, &b, &c, &d)) {
+        return NULL;
+    }
+    Py_INCREF(e);
+    Py_XDECREF(error_type);
+    error_type = e;
+    Py_INCREF(a);
+    Py_XDECREF(py_to_jalaali);
+    py_to_jalaali = a;
+    Py_INCREF(b);
+    Py_XDECREF(py_to_gregorian);
+    py_to_gregorian = b;
+    Py_INCREF(c);
+    Py_XDECREF(py_is_leap_year);
+    py_is_leap_year = c;
+    Py_INCREF(d);
+    Py_XDECREF(py_month_length);
+    py_month_length = d;
+    Py_RETURN_NONE;
+}
+
+static PyMethodDef methods[] = {
+    {"to_jalaali", calgo_to_jalaali, METH_VARARGS,
+     "to_jalaali(gy, gm, gd) -> (jy, jm, jd)"},
+    {"to_gregorian", calgo_to_gregorian, METH_VARARGS,
+     "to_gregorian(jy, jm, jd) -> (gy, gm, gd)"},
+    {"is_leap_year", calgo_is_leap_year, METH_VARARGS,
+     "is_leap_year(jy) -> bool"},
+    {"month_length", calgo_month_length, METH_VARARGS,
+     "month_length(jy, jm) -> int"},
+    {"setup", calgo_setup, METH_VARARGS,
+     "setup(error_type, to_jalaali, to_gregorian, is_leap_year, "
+     "month_length): register the exception class and Python fallbacks"},
+    {NULL, NULL, 0, NULL},
+};
+
+static struct PyModuleDef module = {
+    PyModuleDef_HEAD_INIT, "djalaali._calgo", NULL, -1, methods,
+};
+
+PyMODINIT_FUNC
+PyInit__calgo(void)
+{
+    return PyModule_Create(&module);
+}

djalaali-0.1.0/djalaali/algo.py

@@ -0,0 +1,235 @@
+"""
+jalaali - A Python implementation of the Jalaali calendar conversion.
+
+Ported from https://github.com/jalaali/go-jalaali
+"""
+
+import os
+from enum import IntEnum
+
+# Jalaali leap year break points
+BREAKS = [
+    -61,
+    9,
+    38,
+    199,
+    426,
+    686,
+    756,
+    818,
+    1111,
+    1181,
+    1210,
+    1635,
+    2060,
+    2097,
+    2192,
+    2262,
+    2324,
+    2394,
+    2456,
+    3178,
+]
+
+
+class Month(IntEnum):
+    """Represents a Jalaali month (1-12)."""
+
+    Farvardin = 1
+    Ordibehesht = 2
+    Khordad = 3
+    Tir = 4
+    Mordad = 5
+    Shahrivar = 6
+    Mehr = 7
+    Aban = 8
+    Azar = 9
+    Dey = 10
+    Bahman = 11
+    Esfand = 12
+
+
+class ErrorInvalidYear(Exception):
+    """Raised when year is out of valid range."""
+
+    def __init__(self, year):
+        self.year = year
+        super().__init__(f"jalaali: {year} is invalid year")
+
+
+def _div(a, b):
+    """Integer division truncated toward zero (matches Go's `/` for ints)."""
+    q = abs(a) // abs(b)
+    if (a < 0) != (b < 0):
+        q = -q
+    return q
+
+
+def _mod(a, b):
+    """Remainder with sign of dividend (matches Go's `%` for ints)."""
+    r = abs(a) % abs(b)
+    if a < 0:
+        r = -r
+    return r
+
+
+def to_jalaali(gy, gm, gd):
+    """
+    Convert a Gregorian date to a Jalaali date.
+
+    Returns a tuple (jy, jm, jd).
+    Raises ErrorInvalidYear if the resulting Jalaali year is out of range.
+    """
+    return _d2j(_g2d(gy, gm, gd))
+
+
+def to_gregorian(jy, jm, jd):
+    """
+    Convert a Jalaali date to a Gregorian date.
+
+    Returns a tuple (gy, gm, gd).
+    Raises ValueError for an invalid Jalaali date.
+    Raises ErrorInvalidYear if the year is out of range.
+    """
+    if not _is_valid_date(jy, jm, jd):
+        raise ValueError(
+            f"invalid jalaali date: year={jy}, month={jm}, day={jd}"
+        )
+    jdn = _j2d(jy, jm, jd)
+    return _d2g(jdn)
+
+
+def is_leap_year(jy):
+    """Return True if the given Jalaali year is a leap year."""
+    leap, _, _, _ = _jal_cal(jy)
+    return leap == 0
+
+
+def month_length(jy, jm):
+    """Return the number of days in the given Jalaali month."""
+    if jm <= 6:
+        return 31
+    elif jm <= 11:
+        return 30
+    if is_leap_year(jy):
+        return 30
+    return 29
+
+
+def _is_valid_date(jy, jm, jd):
+    if jy < -61 or jy > 3177 or jm < 1 or jm > 12 or jd < 1:
+        return False
+    return jd <= month_length(jy, jm)
+
+
+def _j2d(jy, jm, jd):
+    _, gy, march, _ = _jal_cal(jy)
+    return _g2d(gy, 3, march) + (jm - 1) * 31 - _div(jm, 7) * (jm - 7) + jd - 1
+
+
+def _d2j(jdn):
+    gy, _, _ = _d2g(jdn)
+    jy = gy - 621
+    leap, _, march, _ = _jal_cal(jy)
+    jdn1f = _g2d(gy, 3, march)
+    k = jdn - jdn1f
+    if k >= 0:
+        if k <= 185:
+            jm = 1 + _div(k, 31)
+            jd = _mod(k, 31) + 1
+            return jy, jm, jd
+        k -= 186
+    else:
+        jy -= 1
+        k += 179
+        if leap == 1:
+            k += 1
+    jm = 7 + _div(k, 30)
+    jd = _mod(k, 30) + 1
+    return jy, jm, jd
+
+
+def _jal_cal(jy):
+    bl = len(BREAKS)
+    gy = jy + 621
+    leap_j = -14
+    jp = BREAKS[0]
+    jump = 0
+
+    if jy < jp or jy >= BREAKS[bl - 1]:
+        raise ErrorInvalidYear(jy)
+
+    for i in range(1, bl):  # pragma: no branch
+        jm = BREAKS[i]
+        jump = jm - jp
+        if jy < jm:
+            break
+        leap_j += _div(jump, 33) * 8 + _div(_mod(jump, 33), 4)
+        jp = jm
+
+    n = jy - jp
+    leap_j += _div(n, 33) * 8 + _div(_mod(n, 33) + 3, 4)
+    if _mod(jump, 33) == 4 and jump - n == 4:
+        leap_j += 1
+
+    leap_g = _div(gy, 4) - _div((_div(gy, 100) + 1) * 3, 4) - 150
+    march = 20 + leap_j - leap_g
+
+    if jump - n < 6:
+        n = n - jump + _div(jump + 4, 33) * 33
+
+    leap = _mod(_mod(n + 1, 33) - 1, 4)
+    if leap == -1:
+        leap = 4
+
+    return leap, gy, march, None
+
+
+def _g2d(gy, gm, gd):
+    d = (
+        _div((gy + _div(gm - 8, 6) + 100100) * 1461, 4)
+        + _div(153 * _mod(gm + 9, 12) + 2, 5)
+        + gd
+        - 34840408
+    )
+    d = d - _div(_div(gy + 100100 + _div(gm - 8, 6), 100) * 3, 4) + 752
+    return d
+
+
+def _d2g(jdn):
+    j = 4 * jdn + 139361631
+    j = j + _div(_div(4 * jdn + 183187720, 146097) * 3, 4) * 4 - 3908
+    i = _div(_mod(j, 1461), 4) * 5 + 308
+    gd = _div(_mod(i, 153), 5) + 1
+    gm = _mod(_div(i, 153), 12) + 1
+    gy = _div(j, 1461) - 100100 + _div(8 - gm, 6)
+    return gy, gm, gd
+
+
+# Keep the pure-Python implementations reachable (tests compare them against
+# the C accelerator), then swap in the C versions when they are available.
+_py_to_jalaali = to_jalaali
+_py_to_gregorian = to_gregorian
+_py_is_leap_year = is_leap_year
+_py_month_length = month_length
+
+HAS_C_EXTENSION = False
+
+if not os.environ.get("DJALAALI_PURE_PYTHON"):  # pragma: no cover
+    try:
+        from . import _calgo
+    except ImportError:
+        pass
+    else:
+        _calgo.setup(
+            ErrorInvalidYear,
+            _py_to_jalaali,
+            _py_to_gregorian,
+            _py_is_leap_year,
+            _py_month_length,
+        )
+        to_jalaali = _calgo.to_jalaali
+        to_gregorian = _calgo.to_gregorian
+        is_leap_year = _calgo.is_leap_year
+        month_length = _calgo.month_length
+        HAS_C_EXTENSION = True