kinegratii__borax-23

The user is reporting a bug in `borax.calendars.lunardate.TextUtils.day_cn` where the Chinese names for the 20th and 30th days of the lunar month are incorrect.
Specifically, "廿十" should be "二十" and "卅十" should be "三十".
"廿" (niàn) already means 20, and "卅" (sà) already means 30. Adding "十" (ten) after them is redundant and incorrect.

I need to:
1.  Locate `borax/calendars/lunardate.py` and the `TextUtils` class.
2.  Identify the `day_cn` method and its logic.
3.  Create a reproduction script to verify the bug.
4.  Fix the logic in `day_cn`.
5.  Verify the fix with the reproduction script and existing tests.

Let's start by locating and reading the code.

{
  "command": "grep -rn --include=\"*.py\" \"def day_cn\" borax/calendars/"
}

{
  "status": "ok",
  "stdout": "borax/calendars/lunardate.py:352:    def day_cn(day: int) -> str:\n",
  "stderr": "",
  "exit_code": 0
}

The method `day_cn` is in `borax/calendars/lunardate.py` around line 352.
Let's read that file around those lines.

{
  "end_line": 370,
  "filepath": "borax/calendars/lunardate.py",
  "start_line": 340
}

{
  "status": "ok",
  "filepath": "borax/calendars/lunardate.py",
  "content": "    ANIMALS = '鼠牛虎兔龙蛇马羊猴鸡狗猪'\n\n    @staticmethod\n    def year_cn(year: int) -> str:\n        s = ''.join([TextUtils.MONTHS_CN[int(c)] for c in str(year)])\n        return s.replace('正', '一')\n\n    @staticmethod\n    def month_cn(month: int) -> str:\n        return TextUtils.MONTHS_CN[month]\n\n    @staticmethod\n    def day_cn(day: int) -> str:\n        a, b = divmod(day, 10)\n        if b == 0:  # 10,20,30\n            b = 10\n            if a == 1:  # 10\n                a = 0\n        return TextUtils.TENS[a] + TextUtils.DAYS_CN[b]\n\n    @staticmethod\n    def get_gz_cn(offset: int) -> str:\n        \"\"\"Get n-th(0-based) GanZhi\n        \"\"\"\n        return TextUtils.STEMS[offset % 10] + TextUtils.BRANCHES[offset % 12]\n\n\nclass LunarDate(EncoderMixin):\n    fields = [f_year, f_month, f_day, f_leap]\n\n    def __init__(self, year: int, month: int, day: int, leap: Leap = False):",
  "start_line": 340,
  "end_line": 370,
  "total_lines": 679,
  "is_truncated": false
}

I need to see `TextUtils.TENS` and `TextUtils.DAYS_CN`. They are probably defined earlier in the `TextUtils` class.

{
  "end_line": 350,
  "filepath": "borax/calendars/lunardate.py",
  "start_line": 300
}

{
  "status": "ok",
  "filepath": "borax/calendars/lunardate.py",
  "content": "        value_offset = [0, 15]\n        year_index = year - 1900\n        days = [int(c) + value_offset[i % 2] for i, c in enumerate(TERM_INFO[year_index])]\n        return days\n\n    @staticmethod\n    def get_term_info(year, month, day):\n        \"\"\"Parse solar term and stem-branch year/month/day from a solar date.\n        (sy, sm, sd) => (term, next_gz_month)\n        term for year 2101,:2101.1.5(初六) 小寒 2101.1.20(廿一) 大寒\n        \"\"\"\n        if year == 2101:\n            days = [5, 20]\n        else:\n            days = TermUtils.parse_term_days(year)\n        term_index1 = 2 * (month - 1)\n        term_index2 = 2 * (month - 1) + 1\n        day1 = days[term_index1]\n        day2 = days[term_index2]\n        if day == day1:\n            term_name = TERMS_CN[term_index1]\n        elif day == day2:\n            term_name = TERMS_CN[term_index2]\n        else:\n            term_name = None\n\n        next_gz_month = day >= day1\n        return term_name, next_gz_month\n\n\n# ------ Stems and Branches ------\n\n\nclass TextUtils:\n    MONTHS_CN = '〇正二三四五六七八九十冬腊'\n    TENS = '初十廿卅'\n    DAYS_CN = '日一二三四五六七八九十'\n\n    STEMS = '甲乙丙丁戊己庚辛壬癸'\n    BRANCHES = '子丑寅卯辰巳午未申酉戌亥'\n    ANIMALS = '鼠牛虎兔龙蛇马羊猴鸡狗猪'\n\n    @staticmethod\n    def year_cn(year: int) -> str:\n        s = ''.join([TextUtils.MONTHS_CN[int(c)] for c in str(year)])\n        return s.replace('正', '一')\n\n    @staticmethod\n    def month_cn(month: int) -> str:\n        return TextUtils.MONTHS_CN[month]\n",
  "start_line": 300,
  "end_line": 350,
  "total_lines": 679,
  "is_truncated": false
}

The constants are:
`TENS = '初十廿卅'` (indices: 0:'初', 1:'十', 2:'廿', 3:'卅')
`DAYS_CN = '日一二三四五六七八九十'` (indices: 0:'日', 1:'一', ..., 9:'九', 10:'十')

Let's trace `day_cn(20)`:
`day = 20`
`a, b = divmod(20, 10)` -> `a = 2, b = 0`
`if b == 0: b = 10` -> `b = 10`
`if a == 1: ...` -> `a` is 2, no change.
Return `TextUtils.TENS[2] + TextUtils.DAYS_CN[10]` -> `'廿' + '十'` -> `'廿十'`.
This is exactly what the user reported.

For `day_cn(30)`:
`day = 30`
`a, b = divmod(30, 10)` -> `a = 3, b = 0`
`if b == 0: b = 10` -> `b = 10`
Return `TextUtils.TENS[3] + TextUtils.DAYS_CN[10]` -> `'卅' + '十'` -> `'卅十'`.

For `day_cn(10)`:
`day = 10`
`a, b = divmod(10, 10)` -> `a = 1, b = 0`
`if b == 0: b = 10` -> `b = 10`
`if a == 1: a = 0` -> `a = 0`
Return `TextUtils.TENS[0] + TextUtils.DAYS_CN[10]` -> `'初' + '十'` -> `'初十'`.
Wait, is "初十" correct? Yes, the 10th day of the lunar month is "初十", whereas the 1st is "初一".

Wait, let's check `day_cn(1)`:
`day = 1`
`a, b = divmod(1, 10)` -> `a = 0, b = 1`
Return `TextUtils.TENS[0] + TextUtils.DAYS_CN[1]` -> `'初' + '一'` -> `'初一'`. Correct.

The problem is that when `a` is 2 or 3 (for 20 and 30), it should still behave like `a=1` (for 10) in terms of not adding "十" if `b=10`, OR it should just use "二十" and "三十".

Actually, if `a=2` and `b=10`, it should be "二十".
If `a=3` and `b=10`, it should be "三十".

Wait, `TENS[2]` is '廿' (20) and `TENS[3]` is '卅' (30).
If the user wants "二十", they want `TENS[1] + DAYS_CN[10]`? No, `TENS[1]` is '十'.
`TENS[1] + DAYS_CN[10]` would be '十十'.

Wait, let's re-examine `TENS` and `DAYS_CN`.
`TENS = '初十廿卅'`
`DAYS_CN = '日一二三四五六七八九十'`

`day_cn(10)` -> `a=0, b=10` -> `TENS[0] + DAYS_CN[10]` -> `'初十'`
`day_cn(20)` -> `a=2, b=10` -> `TENS[2] + DAYS_CN[10]` -> `'廿十'`

If we want `day_cn(20)` to be `"二十"`, we can't use `TENS[2]` ('廿').
We should use `TENS[1]` ('十') + `DAYS_CN[2]` ('二')? No, `DAYS_CN[2]` is '二'.
`TENS[1] + DAYS_CN[2]` -> `'十二'`.
`TENS[1] + DAYS_CN[10]` would be `'十十'`.

Wait, the user says:
`print(TextUtils.day_cn(20)) # “廿十” -> should be “二十”`
`print(TextUtils.day_cn(30)) # “卅十” -> should be “三十”`

If `day=20`, `a=2, b=0`.
Current code: `a=2, b=10`. Result: `TENS[2]+DAYS_CN[10]` = `'廿' + '十'`.
Desired: `"二十"`.
"二十" is `TENS[1]` ('十') + `DAYS_CN[2]` ('二')? No, that's 12.

Wait, let's look at the Chinese numbering.
1: 初一 (chu yi)
10: 初十 (chu shi)
11: 十一 (shi yi)
20: 二十 (er shi)
21: 二十一 (er shi yi)
30: 三十 (san shi)

Ah!
For days 11-19, `a = divmod(day, 10)` would be `a=1, b=1-9`.
`day_cn(11)`: `a=1, b=1`. `a` is not 0. `TENS[1] + DAYS_CN[1]` -> `'十' + '一'` -> `'十一'`. Correct.
`day_cn(19)`: `a=1, b=9`. `TENS[1] + DAYS_CN[9]` -> `'十' + '九'` -> `'十九'`. Correct.

For days 20-29:
`day_cn(20)`: `a=2, b=0` -> `a=2, b=10` -> `TENS[2] + DAYS_CN[10]` -> `'廿十'`.
Wait, for 20, it should be `"二十"`. This means `DAYS_CN[2] + TENS[1]`? No.
`"二十"` is `DAYS_CN[2]` ('二') + `TENS[1]` ('十').

Wait, `DAYS_CN` is `日一二三四五六七八九十`.
`DAYS_CN[2]` is `'二'`.
`TENS[1]` is `'十'`.
So `"二十"` is `DAYS_CN[2] + TENS[1]`.

But for 21:
`day_cn(21)`: `a=2, b=1`. Result: `TENS[2] + DAYS_CN[1]` -> `'廿一'`.
Is "廿一" correct? Yes, it is commonly used for 21st.
Is "二十一" also correct? Yes.

The user specifically complained about "廿十" and "卅十".
"廿" means 20. "廿十" means 20+10 = 30? No, it's just a mistake.
"廿" already means 20. So "廿" is 20. But usually, for the 20th, we say "二十".
Actually, in some contexts "廿" is used, but "廿十" is definitely wrong. "二十" is the standard for 20.

Let's check 30.
`day_cn(30)`: `a=3, b=0` -> `a=3, b=10` -> `TENS[3] + DAYS_CN[10]` -> `'卅十'`.
"卅" means 30. "卅十" is wrong. It should be "三十".
"三十" is `DAYS_CN[3]` ('三') + `TENS[1]` ('十').

So:
- If `day == 20`, result should be `"二十"`.
- If `day == 30`, result should be `"三十"`.

What about 21-29?
`day_cn(21)` -> `TENS[2] + DAYS_CN[1]` -> `'廿一'`. This is usually fine.
`day_cn(31)` (rare but possible in some calendars, though not lunar) -> `TENS[3] + DAYS_CN[1]` -> `'卅一'`.

Wait, let's see if there are other ways to get `"二十"` and `"三十"`.
Current `day_cn` implementation:
```python
    @staticmethod
    def day_cn(day: int) -> str:
        a, b = divmod(day, 10)
        if b == 0:  # 10,20,30
            b = 10
            if a == 1:  # 10
                a = 0
        return TextUtils.TENS[a] + TextUtils.DAYS_CN[b]
```

For `day=20`: `a=2, b=0` -> `a=2, b=10`. Return `TENS[2] + DAYS_CN[10] = '廿' + '十' = '廿十'`.
If we want `"二十"`, we can't just change `TENS` or `DAYS_CN` indices because they are used elsewhere.

If `day=20`, we want `"二十"`.
If `day=30`, we want `"三十"`.

Wait, if `day=20`, `a=2, b=0`.
If we change the logic to:
If `day == 20`: return `"二十"`
If `day == 30`: return `"三十"`

But we should try to be more elegant if possible.
For `day=20`, `a=2, b=0`.
If `b == 0` and `a >= 2`:
`day=20` -> `a=2, b=10`. We want `DAYS_CN[2] + TENS[1]` = `'二' + '十'`.
`day=30` -> `a=3, b=10`. We want `DAYS_CN[3] + TENS[1]` = `'三' + '十'`.

However, for `day=10`, `a=1, b=0` -> `a=0, b=10`. Return `TENS[0] + DAYS_CN[10]` = `'初十'`. This is correct.

So the special cases are `day=20` and `day=30`.

Let's create a reproduction script to confirm.

{
  "command": "python3 - <<'PY'\nfrom borax.calendars.lunardate import LunarDate, TextUtils\n\nprint(f\"day_cn(20): {TextUtils.day_cn(20)}\")\nprint(f\"day_cn(30): {TextUtils.day_cn(30)}\")\n\nld20 = LunarDate(2020, 10, 20, 0)\nprint(f\"ld20.cn_day: {ld20.cn_day}\")\nprint(f\"ld20.cn_day_calendar: {ld20.cn_day_calendar}\")\nprint(f\"ld20.cn_str(): {ld20.cn_str()}\")\n\nld30 = LunarDate(2020, 10, 30, 0)\nprint(f\"ld30.cn_day: {ld30.cn_day}\")\nprint(f\"ld30.cn_day_calendar: {ld30.cn_day_calendar}\")\nprint(f\"ld30.cn_str(): {ld30.cn_str()}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "day_cn(20): 廿十\nday_cn(30): 卅十\nld20.cn_day: 廿十\nld20.cn_day_calendar: 廿十\nld20.cn_str(): 二〇二〇年十月廿十\nld30.cn_day: 卅十\nld30.cn_day_calendar: 卅十\nld30.cn_str(): 二〇二〇年十月卅十\n",
  "stderr": "",
  "exit_code": 0
}

Confirmed. Now I need to fix `day_cn`.

```python
    @staticmethod
    def day_cn(day: int) -> str:
        a, b = divmod(day, 10)
        if b == 0:  # 10,20,30
            b = 10
            if a == 1:  # 10
                a = 0
        return TextUtils.TENS[a] + TextUtils.DAYS_CN[b]
```

If `day == 20`, `a=2, b=10`. result `'廿十'`.
If `day == 30`, `a=3, b=10`. result `'卅十'`.

If we change the loop for `b == 0`:
```python
        if b == 0:  # 10,20,30
            if a == 1:  # 10
                return '初十'
            if a == 2:  # 20
                return '二十'
            if a == 3:  # 30
                return '三十'
            b = 10
```
Wait, `a` could be 0? No, `day` is at least 1.
`day=10` -> `a=1, b=0`. Returns '初十'. Correct.
`day=20` -> `a=2, b=0`. Returns '二十'. Correct.
`day=30` -> `a=3, b=0`. Returns '三十'. Correct.

What about other `b == 0`? `day=40` (not possible in lunar), `day=0` (not possible).
What about `day=1-9`? `a=0, b=1-9`. `TENS[0] + DAYS_CN[1-9]` -> '初' + '一'..'九'. Correct.
What about `day=11-19`? `a=1, b=1-9`. `TENS[1] + DAYS_CN[1-9]` -> '十' + '一'..'九'. Correct.
What about `day=21-29`? `a=2, b=1-9`. `TENS[2] + DAYS_CN[1-9]` -> '廿' + '一'..'九'. Correct.
What about `day=31`? `a=3, b=1`. `TENS[3] + DAYS_CN[1]` -> '卅一'. Correct.

So the fix is:
```python
    @staticmethod
    def day_cn(day: int) -> str:
        a, b = divmod(day, 10)
        if b == 0:  # 10, 20, 30
            if a == 1: return '初十'
            if a == 2: return '二十'
            if a == 3: return '三十'
            b = 10 # fallback for other multiples of 10 if any
        return TextUtils.TENS[a] + TextUtils.DAYS_CN[b]
```

Actually, we can just do:
```python
    @staticmethod
    def day_cn(day: int) -> str:
        if day == 10: return '初十'
        if day == 20: return '二十'
        if day == 30: return '三十'
        a, b = divmod(day, 10)
        if b == 0:
             b = 10
        return TextUtils.TENS[a] + TextUtils.DAYS_CN[b]
```
Wait, if `day=10`, `a=1, b=0`.
If we remove the `if day == 10` etc, and just use the original logic:
`day=10` -> `a=1, b=0` -> `b=10, a=0` -> `TENS[0] + DAYS_CN[10]` = `'初十'`.
`day=20` -> `a=2, b=0` -> `b=10, a=2` -> `TENS[2] + DAYS_CN[10]` = `'廿十'`.

So we just need to handle `day=20` and `day=30`.

```python
    @staticmethod
    def day_cn(day: int) -> str:
        if day == 20: return '二十'
        if day == 30: return '三十'
        a, b = divmod(day, 10)
        if b == 0:  # 10
            b = 10
            if a == 1:  # 10
                a = 0
        return TextUtils.TENS[a] + TextUtils.DAYS_CN[b]
```

Wait, if `day=20`, `divmod(20, 10)` is `(2, 0)`.
If `day=30`, `divmod(30, 10)` is `(3, 0)`.

Let's see if we can make it more concise.

```python
    @staticmethod
    def day_cn(day: int) -> str:
        a, b = divmod(day, 10)
        if b == 0:  # 10, 20, 30
            if a == 1: return '初十'
            if a == 2: return '二十'
            if a == 3: return '三十'
            b = 10
        return TextUtils.TENS[a] + TextUtils.DAYS_CN[b]
```

Wait, for `day=10`, `a=1, b=0`. It returns `'初十'`.
Original code for `day=10`: `a=1, b=0` -> `b=10, a=0` -> `TENS[0]+DAYS_CN[10]` = `'初十'`.
So it's equivalent.

For `day=20`, `a=2, b=0`. It returns `'二十'`.
For `day=30`, `a=3, b=0`. It returns `'三十'`.

What if `day` is something else? `day=1` -> `a=0, b=1`. Returns `TENS[0]+DAYS_CN[1]` = `'初一'`. Correct.
`day=11` -> `a=1, b=1`. Returns `TENS[1]+DAYS_CN[1]` = `'十一'`. Correct.
`day=21` -> `a=2, b=1`. Returns `TENS[2]+DAYS_CN[1]` = `'廿一'`. Correct.
`day=31` -> `a=3, b=1`. Returns `TENS[3]+DAYS_CN[1]` = `'卅一'`. Correct.

One more thing: `TENS` and `DAYS_CN` constants.
`TENS = '初十廿卅'`
`DAYS_CN = '日一二三四五六七八九十'`

For `day=10`, `a=1, b=0`.
If we want to use the constants:
`TENS[0] + DAYS_CN[10]` = `'初' + '十' = '初十'`.

For `day=20`, `a=2, b=0`.
We want `'二十'`. That's `DAYS_CN[2] + TENS[1]`.

For `day=30`, `a=3, b=0`.
We want `'三十'`. That's `DAYS_CN[3] + TENS[1]`.

So we could do:
```python
    @staticmethod
    def day_cn(day: int) -> str:
        a, b = divmod(day, 10)
        if b == 0:  # 10, 20, 30
            if a == 1:
                return TextUtils.TENS[0] + TextUtils.DAYS_CN[10]
            if a == 2:
                return TextUtils.DAYS_CN[2] + TextUtils.TENS[1]
            if a == 3:
                return TextUtils.DAYS_CN[3] + TextUtils.TENS[1]
            b = 10
        return TextUtils.TENS[a] + TextUtils.DAYS_CN[b]
```
But using literal strings `'初十'`, `'二十'`, `'三十'` is clearer and less dependent on the index of constants if they change (though they shouldn't).

Actually, let's look at the current code again.
```python
    @staticmethod
    def day_cn(day: int) -> str:
        a, b = divmod(day, 10)
        if b == 0:  # 10,20,30
            b = 10
            if a == 1:  # 10
                a = 0
        return TextUtils.TENS[a] + TextUtils.DAYS_CN[b]
```
If `a=2, b=10`, it returns `TENS[2] + DAYS_CN[10] = '廿十'`.
If `a=3, b=10`, it returns `TENS[3] + DAYS_CN[10] = '卅十'`.

If I change it to:
```python
    @staticmethod
    def day_cn(day: int) -> str:
        a, b = divmod(day, 10)
        if b == 0:  # 10,20,30
            if a == 1: return '初十'
            if a == 2: return '二十'
            if a == 3: return '三十'
            b = 10
        return TextUtils.TENS[a] + TextUtils.DAYS_CN[b]
```
This looks correct and minimal.

Wait, just wondering if "二十" should use the constants.
`DAYS_CN[2]` is '二'. `TENS[1]` is '十'.
`DAYS_CN[3]` is '三'. `TENS[1]` is '十'.
`TENS[0]` is '初'. `DAYS_CN[10]` is '十'.

So:
- 10: `TENS[0] + DAYS_CN[10]`
- 20: `DAYS_CN[2] + TENS[1]`
- 30: `DAYS_CN[3] + TENS[1]`

Wait, `TENS[1]` is `'十'`. `DAYS_CN[10]` is also `'十'`.
`TENS = '初十廿卅'`
`DAYS_CN = '日一二三四五六七八九十'`

Yes, both `TENS[1]` and `DAYS_CN[10]` are '十'.

Let's use the literal strings for simplicity and clarity.

Wait, one more check. What is `day_cn(20)` supposed to be according to the issue? `"二十"`.
What about `day_cn(10)`? The issue doesn't mention it, but the current code produces `"初十"`. Is `"初十"` correct?
In Chinese lunar calendar:
1st: 初一 (chū yī)
...
9th: 初九 (chū jiǔ)
10th: 初十 (chū shí)
11th: 十一 (shí yī)
...
19th: 十九 (shí jiǔ)
20th: 二十 (èr shí)
...
29th: 二十九 (èr shí jiǔ)
30th: 三十 (sān shí)

So:
1-10: 初 + (1-10)
11-19: 十 + (1-9)
20-29: 二 + 十 + (0-9) -> Wait, 20 is 二十, 21 is 二十一.
30: 三十.

My proposed logic:
`day=1-9`: `a=0, b=1-9`. Result: `TENS[0] + DAYS_CN[1-9]` = `初` + `一`..`九`. Correct.
`day=10`: `a=1, b=0`. Result: `'初十'`. Correct.
`day=11-19`: `a=1, b=1-9`. Result: `TENS[1] + DAYS_CN[1-9]` = `十` + `一`..`九`. Correct.
`day=20`: `a=2, b=0`. Result: `'二十'`. Correct.
`day=21-29`: `a=2, b=1-9`. Result: `TENS[2] + DAYS_CN[1-9]` = `廿` + `一`..`九`.
Wait, is `廿一` (niàn yī) correct for 21? Yes, it is a very common way to write 21 in lunar dates.
Is `二十一` also correct? Yes.
The issue only mentions `廿十` and `卅十`. It doesn't say `廿一` is wrong.
In fact, the user says:
`print(TextUtils.day_cn(20)) # “廿十”`
They don't mention 21.

Wait, if `day=21`, `a=2, b=1`. `TENS[2] + DAYS_CN[1]` = `'廿一'`.
If `day=31`, `a=3, b=1`. `TENS[3] + DAYS_CN[1]` = `'卅一'`.

The user says:
`“廿十”、“卅十” 是不正确的用法，因为“廿”、“卅” 本身就是二十、三十的意思了，正确的应该为“二十”、“三十”。`

This means for 20, it should be "二十", and for 30, it should be "三十".
For 21, "廿一" is likely okay since "廿" means 20. "廿一" = 20 + 1.
And "卅一" = 30 + 1.

So my proposed fix handles exactly what the user wants.

Let's double check the `TENS` and `DAYS_CN` constants again.
`TENS = '初十廿卅'`
`DAYS_CN = '日一二三四五六七八九十'`

For `day=10`:
Original code: `a=1, b=0` -> `b=10, a=0` -> `TENS[0] + DAYS_CN[10]` = `'初' + '十' = '初十'`.
My proposed code: `day=10` -> `a=1, b=0` -> `return '初十'`.
Same result.

For `day=20`:
Original code: `a=2, b=0` -> `b=10, a=2` -> `TENS[2] + DAYS_CN[10]` = `'廿' + '十' = '廿十'`.
My proposed code: `day=20` -> `a=2, b=0` -> `return '二十'`.
Corrected.

For `day=30`:
Original code: `a=3, b=0` -> `b=10, a=3` -> `TENS[3] + DAYS_CN[10]` = `'卅' + '十' = '卅十'`.
My proposed code: `day=30` -> `a=3, b=0` -> `return '三十'`.
Corrected.

I'll implement this.

{
  "filepath": "borax/calendars/lunardate.py",
  "new_string": "    @staticmethod\n    def day_cn(day: int) -> str:\n        a, b = divmod(day, 10)\n        if b == 0:  # 10,20,30\n            if a == 1: return '初十'\n            if a == 2: return '二十'\n            if a == 3: return '三十'\n            b = 10\n        return TextUtils.TENS[a] + TextUtils.DAYS_CN[b]\n",
  "old_string": "    @staticmethod\n    def day_cn(day: int) -> str:\n        a, b = divmod(day, 10)\n        if b == 0:  # 10,20,30\n            b = 10\n            if a == 1:  # 10\n                a = 0\n        return TextUtils.TENS[a] + TextUtils.DAYS_CN[b]\n"
}

{
  "status": "ok",
  "filepath": "borax/calendars/lunardate.py",
  "occurrences": 1,
  "strategy": "exact",
  "diff": "--- a/borax/calendars/lunardate.py\n+++ b/borax/calendars/lunardate.py\n@@ -352,9 +352,10 @@\n     def day_cn(day: int) -> str:\n         a, b = divmod(day, 10)\n         if b == 0:  # 10,20,30\n+            if a == 1: return '初十'\n+            if a == 2: return '二十'\n+            if a == 3: return '三十'\n             b = 10\n-            if a == 1:  # 10\n-                a = 0\n         return TextUtils.TENS[a] + TextUtils.DAYS_CN[b]\n \n     @staticmethod\n",
  "is_truncated": false
}

Now I will verify the fix with the reproduction script.

{
  "command": "python3 - <<'PY'\nfrom borax.calendars.lunardate import LunarDate, TextUtils\n\n# Test cases from the issue\nprint(f\"TextUtils.day_cn(20): {TextUtils.day_cn(20)} (Expected: 二十)\")\nprint(f\"TextUtils.day_cn(30): {TextUtils.day_cn(30)} (Expected: 三十)\")\n\nld20 = LunarDate(2020, 10, 20, 0)\nprint(f\"ld20.cn_day: {ld20.cn_day} (Expected: 二十)\")\nprint(f\"ld20.cn_day_calendar: {ld20.cn_day_calendar} (Expected: 二十)\")\nprint(f\"ld20.cn_str(): {ld20.cn_str()} (Expected to contain: 二十)\")\n\nld30 = LunarDate(2020, 10, 30, 0)\nprint(f\"ld30.cn_day: {ld30.cn_day} (Expected: 三十)\")\nprint(f\"ld30.cn_day_calendar: {ld30.cn_day_calendar} (Expected: 三十)\")\nprint(f\"ld30.cn_str(): {ld30.cn_str()} (Expected to contain: 三十)\")\n\n# Boundary cases\nprint(f\"TextUtils.day_cn(1): {TextUtils.day_cn(1)} (Expected: 初一)\")\nprint(f\"TextUtils.day_cn(10): {TextUtils.day_cn(10)} (Expected: 初十)\")\nprint(f\"TextUtils.day_cn(11): {TextUtils.day_cn(11)} (Expected: 十一)\")\nprint(f\"TextUtils.day_cn(21): {TextUtils.day_cn(21)} (Expected: 廿一)\")\nprint(f\"TextUtils.day_cn(29): {TextUtils.day_cn(29)} (Expected: 廿九)\")\nprint(f\"TextUtils.day_cn(31): {TextUtils.day_cn(31)} (Expected: 卅一)\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "TextUtils.day_cn(20): 二十 (Expected: 二十)\nTextUtils.day_cn(30): 三十 (Expected: 三十)\nld20.cn_day: 二十 (Expected: 二十)\nld20.cn_day_calendar: 二十 (Expected: 二十)\nld20.cn_str(): 二〇二〇年十月二十 (Expected to contain: 二十)\nld30.cn_day: 三十 (Expected: 三十)\nld30.cn_day_calendar: 三十 (Expected: 三十)\nld30.cn_str(): 二〇二〇年十月三十 (Expected to contain: 三十)\nTextUtils.day_cn(1): 初一 (Expected: 初一)\nTextUtils.day_cn(10): 初十 (Expected: 初十)\nTextUtils.day_cn(11): 十一 (Expected: 十一)\nTextUtils.day_cn(21): 廿一 (Expected: 廿一)\nTextUtils.day_cn(29): 廿九 (Expected: 廿九)\nTextUtils.day_cn(31): 卅一 (Expected: 卅一)\n",
  "stderr": "",
  "exit_code": 0
}

The fixes are correct and boundary cases look good.
Now let's run the existing tests for `lunardate` to ensure no regressions.

{
  "command": "pytest borax/calendars/lunardate.py -q --tb=short --no-header || pytest tests/ borax/calendars/lunardate.py -q --tb=short --no-header"
}

{
  "status": "ok",
  "stdout": "\nno tests ran in 0.01s\n........................................................................ [ 56%]\n.......................................................             [100%]\n127 passed, 5 subtests passed in 0.20s\n",
  "stderr": "",
  "exit_code": 0
}

The `pytest tests/` command passed. I'm not sure if I ran the right tests. I should specifically look for tests that test `lunardate`.

{
  "command": "find tests -name \"*lunar*\""
}

{
  "status": "ok",
  "stdout": "tests/test_lunar_benchmark.py\ntests/test_lunardate.py\ntests/test_lunar_sqlite3_feature.py\n",
  "stderr": "",
  "exit_code": 0
}

Let's run those.

{
  "command": "pytest tests/test_lunardate.py -q --tb=short --no-header"
}

{
  "status": "ok",
  "stdout": "................                                                         [100%]\n16 passed in 0.01s\n",
  "stderr": "",
  "exit_code": 0
}