jntajis-python 0.0.13__tar.gz → 0.0.16__tar.gz

jntajis_python-0.0.16/.agents/docs/ARCHITECTURE.md

@@ -0,0 +1,154 @@
+# Architecture
+
+## Project Overview
+
+jntajis-python is a Python library for transliterating and encoding/decoding characters across three Japanese character set standards: JIS X 0208, JIS X 0213, and Unicode. It also supports transliteration via the MJ (Moji Joho) character table and shrink conversion maps.
+
+## Directory Layout
+
+```
+jntajis-python/
+  setup.py                        # setuptools + Cython extension build
+  setup.cfg                       # Package metadata, dependencies, dev extras
+  Makefile                        # Data pipeline: download -> parse -> codegen
+  src/jntajis/
+    __init__.py                   # Public Python API surface (enums + re-exports)
+    _jntajis.pyx                  # Cython implementation (core logic)
+    _jntajis.h                    # Generated C header (lookup tables)
+    _jntajis.pyi                  # Type stubs for the Cython extension
+    _jntajis.c                    # Cython-generated C source (not committed normally)
+    gen.py                        # Code generator: Excel/JSON -> _jntajis.h
+    py.typed                      # PEP 561 marker
+    tests/
+      test_encoder.py             # Tests for encoding/decoding and IncrementalEncoder
+      test_mj_translit.py         # Tests for MJ shrink candidate transliteration
+    xlsx_parser/
+      __init__.py                 # Re-exports read_xlsx
+      parser.py                   # Streaming OpenXML XLSX reader
+      xmlutils.py                 # SAX-style XML parser framework (expat-based)
+  docs/
+    source/
+      api.rst                     # Sphinx API documentation
+      conf.py                     # Sphinx configuration
+      _static/images/             # SVG diagrams
+  .github/workflows/
+    main.yml                      # CI entry point (PR + push + tag triggers)
+    tests.yml                     # Lint (black, flake8, mypy) + test job
+    wheels.yml                    # cibuildwheel multi-platform wheel builds
+```
+
+## High-Level Architecture
+
+The system has three distinct phases: **data pipeline** (build-time), **native extension** (compile-time), and **runtime API** (user-facing).
+
+### 1. Data Pipeline (build-time, `Makefile` + `gen.py`)
+
+External data sources are downloaded and processed into a single generated C header file:
+
+```
+[JNTA Excel] ---+
+[MJ Excel]   ---+--> gen.py (Jinja2 template) --> _jntajis.h (C lookup tables)
+[MJ Shrink JSON]+
+```
+
+- **JNTA Excel** (`jissyukutaimap1_0_0.xlsx`): NTA shrink conversion map. Downloaded from NTA.
+- **MJ Excel** (`mji.00601.xlsx`): MJ character table. Downloaded from CITPC/IPA.
+- **MJ Shrink JSON** (`MJShrinkMap.1.2.0.json`): MJ shrink conversion map. Downloaded from CITPC/IPA.
+
+`gen.py` uses a custom `xlsx_parser` to read the Excel files, processes the data into optimized lookup structures, and renders `_jntajis.h` via a Jinja2 template. The generated header contains:
+
+- `tx_mappings[]`: 2*94*94 entries, one per JIS X 0213 codepoint (men-ku-ten)
+- `urange_to_jis_mappings[]`: Sorted ranges for Unicode-to-JIS binary search
+- `sm_uni_to_jis_mapping()`: State machine for multi-codepoint Unicode-to-JIS mapping
+- `urange_to_mj_mappings[]`: Sorted ranges for Unicode-to-MJ-mapping-set binary search
+- `mj_shrink_mappings[]`: MJ shrink mapping unicode sets indexed by MJ code
+
+### 2. Native Extension (compile-time, Cython)
+
+`_jntajis.pyx` is a Cython file compiled into a C extension module. It:
+
+- Includes `_jntajis.h` via `cdef extern` to access the generated lookup tables
+- Uses CPython internal APIs (`_PyUnicodeWriter`, `_PyBytesWriter`, `PyUnicode_READ`, etc.) directly for high-performance string construction
+- Compiles with safety checks disabled (`boundscheck=False`, `wraparound=False`, `cdivision=True`)
+
+The build process is: `_jntajis.pyx` + `_jntajis.h` --> Cython --> `_jntajis.c` --> C compiler --> `_jntajis.so`.
+
+### 3. Runtime API
+
+The public API is exposed via `__init__.py` which re-exports from the Cython extension:
+
+| Symbol | Type | Description |
+|--------|------|-------------|
+| `jnta_encode()` | function | Unicode -> JIS byte sequence |
+| `jnta_decode()` | function | JIS byte sequence -> Unicode |
+| `jnta_shrink_translit()` | function | JNTA shrink transliteration (Unicode -> Unicode) |
+| `mj_shrink_candidates()` | function | MJ-based shrink transliteration candidates |
+| `IncrementalEncoder` | class | Stateful encoder (codec-compatible) |
+| `TransliterationError` | exception | Raised on transliteration failure |
+| `ConversionMode` | enum | Encoding mode selection |
+| `MJShrinkScheme` | enum | Individual MJ shrink scheme identifiers |
+| `MJShrinkSchemeCombo` | flag enum | Combinable MJ shrink scheme selectors |
+
+## Key Data Structures
+
+### JIS Code Representation
+
+JIS codepoints are packed into a `uint16_t` as: `(men - 1) * 94 * 94 + (ku - 1) * 94 + (ten - 1)`, where men is 1 or 2 (JIS X 0213 plane), ku is 1-94 (row), ten is 1-94 (column).
+
+### ShrinkingTransliterationMapping
+
+Each JIS X 0213 position has an entry:
+- `jis`: packed men-ku-ten code
+- `us[2]`: primary Unicode codepoint(s)
+- `sus[2]`: secondary (similar glyph) Unicode codepoint(s)
+- `class_`: JIS character class (level 1-4, non-kanji, reserved)
+- `tx_jis[4]`/`tx_us[4]`: transliterated form (JIS and Unicode)
+
+### Unicode-to-JIS Reverse Lookup
+
+Uses sorted range tables (`URangeToJISMapping`) with binary search. Multi-codepoint sequences (e.g. base + combining mark) use a state machine (`sm_uni_to_jis_mapping()`).
+
+### MJ Mapping Structures
+
+- `MJMapping`: Maps an MJ code to Unicode codepoints + IVS (Ideographic Variation Sequence) pairs
+- `MJMappingSet`: A set of MJ mappings for a single Unicode codepoint
+- `URangeToMJMappings`: Sorted range table for Unicode-to-MJ binary search
+- `MJShrinkMappingUnicodeSet`: Per-MJ-code shrink targets, one array per scheme (4 schemes)
+
+## Component Interactions
+
+```
+User code
+  |
+  v
+__init__.py  (Python enums + re-exports)
+  |
+  v
+_jntajis.pyx  (Cython: encoding, decoding, transliteration logic)
+  |
+  v
+_jntajis.h  (Generated C: static lookup tables + state machine)
+```
+
+## xlsx_parser Sub-package
+
+A lightweight, streaming, read-only XLSX parser. It avoids heavyweight dependencies like openpyxl by:
+
+1. Opening XLSX as a zip file (`zipfile.ZipFile`)
+2. Parsing `xl/sharedStrings.xml` for the shared string table
+3. Parsing `xl/worksheets/sheetN.xml` incrementally via SAX-style handlers
+
+The XML parsing framework in `xmlutils.py` provides:
+- A hierarchical `Handlers`/`HandlersBase` abstract pattern where each nesting level of XML is handled by a different handler class
+- `HandlerShim` wraps handlers to dynamically switch the active handler as XML nesting changes
+- `read_xml_incremental()` enables pull-style iteration over worksheet rows
+
+## CI/CD
+
+- **Trigger** (`main.yml`): On PR open, push to main, or version tag push (`v*`)
+- **Lint & Test** (`tests.yml`): black + flake8 + mypy on Python 3.11
+- **Wheels** (`wheels.yml`): cibuildwheel across Ubuntu, Windows, macOS (11/12/13), excluding PyPy. Only runs on tag push.
+
+## Documentation
+
+Sphinx with `sphinx_rtd_theme`, hosted on Read the Docs. API docs are manually authored in `api.rst` (not autodoc).

jntajis_python-0.0.16/.agents/docs/IMPLEMENTATION.md

@@ -0,0 +1,238 @@
+# Implementation Details
+
+## Code Generation (`gen.py`)
+
+### Entry Point
+
+`gen.py` provides a CLI via `click`:
+
+```
+python -m jntajis.gen -- <dest> <src_jnta> <src_mj> <src_mj_shrink>
+```
+
+### Input Parsing
+
+Three source data files are read:
+
+1. **`read_jnta_excel_file()`** parses the NTA shrink map Excel:
+   - Validates header rows match expected Japanese column names
+   - For each row: parses men-ku-ten code, Unicode codepoint(s), JIS character class, transliteration target (single or multi-char)
+   - Fills gaps between consecutive JIS codes with `RESERVED` entries
+   - Extracts secondary Unicode mappings from memo fields via regex
+
+2. **`read_mj_excel_file()`** parses the MJ character table Excel:
+   - Extracts MJ code, corresponding UCS, implemented UCS, IVS pairs (Moji_Joho collection + SVS)
+   - Builds `UIVSPair` tuples (Unicode codepoint + variation selector number)
+   - Tracks max variant count across all entries
+
+3. **`read_mj_shrink_file()`** parses the MJ shrink map JSON:
+   - Reads target Unicode codepoints for each of the 4 shrink schemes
+   - Groups by source MJ code
+
+### Data Structure Construction
+
+1. **`build_reverse_mappings()`**: Builds Unicode-to-JIS reverse lookup:
+   - Sorts all mappings by primary Unicode codepoint
+   - Groups contiguous codepoints into ranges (`URangeToJISMapping`), splitting at gaps >= `gap_thr` (default 256)
+   - Separately collects multi-codepoint sequences into `Outer` groups for the state machine
+
+2. **`build_digested_shrink_mappings()`**: Linearizes MJ shrink mappings:
+   - Creates a dense array indexed by MJ code
+   - Fills gaps with empty tuples
+   - Tracks per-scheme maximum array lengths
+
+3. **`build_chunked_mj_mappings()`**: Builds Unicode-to-MJ reverse lookup:
+   - Groups all MJ mappings by Unicode codepoint
+   - Chunks contiguous ranges, splitting at gaps >= 64
+   - Returns `URangeToMJMappings` list + max mapping set size
+
+### Template Rendering
+
+Uses Jinja2 to render the C header from `code_template`. The template generates:
+
+- `JISCharacterClass` enum
+- `ShrinkingTransliterationMapping` struct and the `tx_mappings[]` array (2 * 94 * 94 entries)
+- Per-range `uint16_t` arrays for Unicode-to-JIS lookup
+- `URangeToJISMapping` array for binary search
+- `sm_uni_to_jis_mapping()` function: a C switch-based state machine for multi-codepoint Unicode sequences
+- MJ-related structs and arrays (`MJMapping`, `MJMappingSet`, `URangeToMJMappings`, `MJShrinkMappingUnicodeSet`)
+
+## Cython Extension (`_jntajis.pyx`)
+
+### Compiler Directives
+
+```cython
+# cython: language_level=3, cdivision=True, boundscheck=False, wraparound=False, embedsignature=True
+```
+
+All safety checks are disabled for performance. `embedsignature=True` embeds Python signatures in docstrings.
+
+### Core Internal Types
+
+- **`JNTAJISIncrementalEncoder`**: Struct holding encoder state:
+  - `encoding`: Python string (ref-counted) for error reporting
+  - `replacement`: Fallback JIS code (0xFFFF = no replacement)
+  - `put_jis`: Function pointer selecting the output strategy
+  - `la[32]`/`lal`: Lookahead buffer for multi-codepoint sequences
+  - `shift_state`/`state`: State machine state
+
+- **`JNTAJISIncrementalEncoderContext`**: Per-call context wrapping the encoder + `_PyBytesWriter` for output construction
+
+- **`JNTAJISShrinkingTransliteratorContext`**: Per-call context for `jnta_shrink_translit`, using `_PyUnicodeWriter` for output
+
+- **`MJShrinkCandidates`**: Manages cartesian product enumeration for `mj_shrink_candidates`
+
+### Encoding Flow (`jnta_encode` / `IncrementalEncoder.encode`)
+
+1. Initialize `_PyBytesWriter` with estimated size (2 * input length)
+2. For each Unicode codepoint in input:
+   a. Feed to `sm_uni_to_jis_mapping()` state machine
+   b. If state machine returns a JIS code (state == -1): call `put_jis` function pointer
+   c. If state machine is still consuming (state > 0): buffer in lookahead
+   d. If state machine returns to state 0 with buffered chars: flush lookahead via reverse table lookup
+3. On flush: flush remaining lookahead, emit shift-out if in SISO mode
+4. Finalize bytes writer
+
+### Output Strategies (`put_jis` function pointers)
+
+| Function | ConversionMode | Behavior |
+|----------|---------------|----------|
+| `jis_put_siso` | SISO | Emits SI/SO escape bytes for plane switching + 2-byte JIS |
+| `jis_put_men_1` | MEN1 | Only allows plane 1; rejects plane 2 characters |
+| `jis_put_jisx0208` | JISX0208 | Only allows level 1/2 kanji and JIS X 0208 non-kanji |
+| `jis_put_jisx0208_translit` | JISX0208_TRANSLIT | Like JISX0208, but falls back to `tx_jis[]`/`tx_us[]` transliteration for non-0208 chars |
+
+### Decoding Flow (`jnta_decode`)
+
+1. Initialize `_PyUnicodeWriter`
+2. Parse byte pairs as JIS row+column codes
+3. Handle SI (0x0E) / SO (0x0F) shift bytes in SISO mode
+4. Look up `tx_mappings[jis]` to get Unicode codepoint(s)
+5. Write 1 or 2 Unicode codepoints per JIS code
+
+### JNTA Shrink Transliteration (`jnta_shrink_translit`)
+
+1. Initialize `_PyUnicodeWriter`
+2. For each Unicode codepoint: use `sm_uni_to_jis_mapping()` to find JIS code
+3. If the JIS code maps to a level 3/4 or non-kanji-extended character with a transliteration entry: output the transliterated form (`tx_us[]`)
+4. Otherwise: output the original Unicode codepoint(s) from `us[]`
+5. If no mapping found: use replacement string or passthrough
+
+### MJ Shrink Candidates (`mj_shrink_candidates`)
+
+This is the most complex function. It:
+
+1. Allocates per-character candidate arrays (`UIVSPair[20]` per position)
+2. For each input character (possibly with trailing IVS):
+   a. Look up `urange_to_mj_mappings` to find candidate `MJMapping` entries
+   b. If IVS present: filter to exact IVS match
+   c. If no IVS: collect all non-IVS variants
+   d. For each matching MJ code, look up `mj_shrink_mappings` and collect target Unicode codepoints per selected scheme (combo bitmask)
+   e. Also include the original Unicode variants from the MJ mapping itself
+   f. If no candidates: keep the original character
+3. Enumerate the cartesian product of per-character candidates (up to `limit`) using carry-based iteration
+4. Build result strings using `_PyUnicodeWriter`
+
+### Binary Search Pattern
+
+Both `lookup_rev_table()` and `lookup_mj_mapping_table()` use the same pattern:
+- Binary search over sorted range arrays
+- Each range has `start`, `end`, and a pointer to a dense sub-array
+- Index into sub-array as `array[u - start]`
+
+### Unicode String Internals Access
+
+The extension directly uses CPython internal APIs for zero-copy string access:
+- `PyUnicode_KIND()`: Get the internal storage width (1/2/4 byte)
+- `PyUnicode_DATA()`: Get raw buffer pointer
+- `PyUnicode_READ()`: Read a codepoint at an index
+- `_PyUnicodeWriter` / `_PyBytesWriter`: Internal buffer builders that handle memory allocation and string compaction
+
+This makes the code CPython-specific and incompatible with other Python implementations.
+
+## xlsx_parser Implementation
+
+### xmlutils.py - XML Framework
+
+The framework builds a hierarchical SAX handler system:
+
+- **`Handlers`** (ABC): Defines `start_element()`, `end_element()`, `cdata()` -- each returns `Optional[Handlers]` to signal handler switching
+- **`HandlersBase`**: Concrete base with `outer` (parent handler), `parser` ref, `path` tuple for error reporting, and `next()` for creating child handlers
+- **`HandlerShim`**: Adapts the handler-switching protocol to expat's flat callback interface; stores the current handler and swaps it when a method returns non-None
+- **`wrap_start_element_handler`**: Decorator that splits `namespace\nlocal_name` and converts attlist to `OrderedDict`
+- **`read_xml_incremental()`**: Drives expat parsing in 4KB chunks, yielding events from a `pull_events` callback between chunks
+
+### parser.py - XLSX Parser
+
+Layered handler hierarchy for each XML document:
+
+**Shared strings** (`xl/sharedStrings.xml`):
+- Level 0 (`SharedStringsReader_0`): Expects `<sst>`
+- Level 1 (`SharedStringsReader_1`): Iterates `<si>` elements
+- Level 2 (`SharedStringsReader_2`): Extracts text from `<t>` within `<si>`
+
+**Worksheet** (`xl/worksheets/sheetN.xml`):
+- Level 0 (`WorksheetReader_0`): Expects `<worksheet>`
+- Level 1 (`WorksheetReader_1`): Handles `<dimension>` and `<sheetData>`
+- Level 2 (`WorksheetReader_2`): Iterates `<row>` elements
+- Level 3 (`WorksheetReader_3`): Iterates `<c>` (cell) elements within a row
+- Level 4 (`WorksheetReader_4`): Extracts `<v>` (value) or `<f>` (formula) content
+
+**`StreamingWorksheetReader`**: Resolves shared string references (`t="s"`) and pads sparse rows into dense arrays based on cell references (e.g. "A1", "C3").
+
+**`ReadonlyWorkbook`/`ReadonlyWorksheet`**: Top-level API wrapping zipfile access with lazy shared string loading and incremental row iteration.
+
+## Python API Layer (`__init__.py`)
+
+### Enums
+
+- **`ConversionMode`** (`IntEnum`): SISO=0, MEN1=1, JISX0208=2, JISX0208_TRANSLIT=3
+- **`MJShrinkScheme`** (`IntEnum`): Four MJ shrink scheme identifiers (0-3)
+- **`MJShrinkSchemeCombo`** (`IntFlag`): Bitmask flags (1, 2, 4, 8) for combining MJ shrink schemes
+
+The Cython extension symbols are imported with a `try/except ImportError` guard so the package can be imported even when the native extension is not built (e.g. for documentation generation).
+
+## Build System
+
+### setup.py / setup.cfg
+
+- Uses `setuptools-scm` for version management (from git tags matching `v*`)
+- Declares a single Cython extension: `jntajis._jntajis` from `src/jntajis/_jntajis.pyx`
+- Requires Cython >= 0.29 at build time
+- No runtime dependencies
+
+### Makefile
+
+Defines the data pipeline with proper dependency tracking:
+
+```
+_jntajis.h <-- gen.py + jissyukutaimap1_0_0.xlsx + mji.00601.xlsx + MJShrinkMap.1.2.0.json
+jissyukutaimap1_0_0.xlsx <-- syukutaimap1_0_0.zip (curl from NTA)
+mji.00601.xlsx <-- mji.00601-xlsx.zip (curl from CITPC)
+MJShrinkMap.1.2.0.json <-- MJShrinkMapVer.1.2.0.zip (curl from CITPC)
+```
+
+### CI/CD
+
+- Lint + test runs on every PR and push to main
+- Wheel builds only on tag push (`v*`)
+- Wheels built via `cibuildwheel` on: Ubuntu 20.04, Windows 2019, macOS 11/12/13
+- PyPy wheels are skipped (`CIBW_SKIP: pp*`)
+
+## Testing
+
+Two test modules using pytest:
+
+- **`test_encoder.py`**: Tests `jnta_encode()` and `IncrementalEncoder` across all `ConversionMode` values. Covers:
+  - Unmapped character encoding errors
+  - Single and multi-codepoint sequences (e.g. katakana with combining marks)
+  - Transliteration fallback (JISX0208_TRANSLIT mode)
+  - Incremental encoding with flush behavior
+  - SISO mode with plane switching
+  - Supplementary plane characters
+
+- **`test_mj_translit.py`**: Tests `mj_shrink_candidates()` with various:
+  - Characters with/without IVS
+  - Different shrink scheme combinations
+  - Characters with multiple shrink candidates
+  - Supplementary plane characters (e.g. U+2AC2A)

{jntajis-python-0.0.13 → jntajis_python-0.0.16}/.gitignore

@@ -148,3 +148,9 @@ MJShrinkMap.1.2.0.json
 MJShrinkMapVer.1.2.0.zip
 mji.00601-xlsx.zip
 mji.00601.xlsx
+
+# hatch-vcs generated version file
+src/jntajis/_version.py
+
+# automatically generated C source
+src/jntajis/_jntajis.c

jntajis_python-0.0.16/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: jntajis-python
+Version: 0.0.16
+Summary: A fast character conversion and transliteration library based on the scheme defined for Japan National Tax Agency's corporate number system.
+Project-URL: Homepage, https://github.com/opencollector/jntajis-python
+Author-email: "Open Collector, inc." <info@opencollector.co.jp>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: JIS,Japanese,Unicode,conversion,encoding,transliteration
+Classifier: Programming Language :: Python :: 3
+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 :: Text Processing :: Filters
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: click>=8.3; extra == 'dev'
+Requires-Dist: jinja2>=3; extra == 'dev'
+Requires-Dist: mypy>=1.19; extra == 'dev'
+Requires-Dist: pytest>=6.2; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Requires-Dist: sphinx-rtd-theme>=0.5; extra == 'dev'
+Requires-Dist: sphinx>=4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# jntajis-python
+
+Documentation: https://jntajis-python.readthedocs.io/
+
+## What's JNTAJIS-python?
+
+JNTAJIS-python is a transliteration library, specifically designed for dealing with three different character sets; JIS X 0208, JIS X 0213, and Unicode.
+
+```python
+import jntajis
+
+print(jntajis.mj_shrink_candidates("髙島屋", jntajis.MJShrinkSchemeCombo.JIS_INCORPORATION_UCS_UNIFICATION_RULE))  # outputs ["高島屋", "髙島屋"]
+print(jntajis.jnta_shrink_translit("麴町"))  # outputs "麹町"
+```
+
+To that end, this library refers to three different character tables; MJ character table, MJ shrink conversion map, and NTA shrink conversion map.
+
+The MJ character table (*MJ文字一覧表*) defines a vast set of kanji (*漢字*) characters used in information processing of Japanese texts initially developed by Information-technology Promotion Agency.
+
+The MJ shrink conversion map (*MJ縮退マップ*) was also developed alongside for the sake of interoperability between MJ-aware systems and systems based on Unicode, which is used to transliterate complex, less-frequently-used character variants to commonly-used, more-used ones.
+
+The NTA shrink conversion map (*国税庁JIS縮退マップ*) was developed by Japan National Tax Agency to canonicalize user inputs for its corporation number search service provided as a public web API.  This maps JIS level 3 and 4 characters to JIS level 1 and 2 characters (i.e. characters defined in JIS X 0208.)  Note that not all level 3 and level 4 characters have level 1 and 2 counterparts.  Also note that some of level 3 and 4 characters don't map to a single character one by each.  Instead, they map to sequences of two or more characters.
+
+The table below shows some examples of transliteration by the MJ character table suite and NTA shrink conversion map.
+
+| Glyph | MJ code | Unicode | JIS X 0213 | Glyph\* | MJ code\* | JIS X 0208\* | Transliterator |
+| ----- | ------- | ------- | ---------- | ------ | ------- | ---------- | -------------- | 
+| ![棃](https://moji.or.jp/mojikibansearch/img/MJ/MJ014031.png) | MJ014031 | U+68C3 | 2-14-90 | ![梨](https://moji.or.jp/mojikibansearch/img/MJ/MJ014007.png) | MJ014007 | 1-45-92 | MJ / JNTA |
+| ![﨑](https://moji.or.jp/mojikibansearch/img/MJ/MJ030196.png) | MJ030196 | U+FA11 | 1-47-82 | ![崎](https://moji.or.jp/mojikibansearch/img/MJ/MJ010541.png) | MJ010541 | 1-26-74 | MJ / JNTA |
+| ![髙](https://moji.or.jp/mojikibansearch/img/MJ/MJ028902.png) | MJ028902 | U+9AD9 | N/A | ![高](https://moji.or.jp/mojikibansearch/img/MJ/MJ028901.png) | MJ028901 | 1-25-66 | MJ |
+
+The conversion schematics is shown below:
+
+![](https://github.com/opencollector/jntajis-python/raw/main/docs/source/_static/images/mj-jnta.svg)
+
+* JNTA transliteration
+
+    As every JIS X 0213 characters maps to its Unicode counterpart, the conversion is done only with the single JNTA character mappings table.
+
+* MJ transliteration
+
+    Transliteration is done in two phases:
+
+    1. Conversion from Unicode to MJ character mappings.
+
+        While not all characters in the MJ characters table map to Unicode, each MJ code has different shrink mappings. Because of this, the transliterator tries to convert Unicode codepoints to MJ codes first.
+
+    2. Transliteration by MJ shrink mappings.
+
+        The transliteration result as a string isn't necessarily single as some MJ codes have more than one transliteration candidate. This happens because a) a Unicode codepoint may map to multiple MJ codes and b) multiple transliteration schemes are designated to a single MJ code.
+
+
+Relationship between Unicode, MJ character mappings, JIS X 0213, and JIS X 0208 can be depicted as follows:
+
+![](https://github.com/opencollector/jntajis-python/raw/main/docs/source/_static/images/relationships-character-mappings.svg)
+
+## License
+
+The source code except `src/jntajis/_jntajis.h` is published under the BSD 3-clause license.
+
+`src/jntajis/_jntajis.h` contains the data from the following entities:
+
+* JIS shrink conversion mappings (国税庁: JIS縮退マップ)
+
+  Publisher: National Tax Agency
+
+  Author: National Tax Agency
+
+  Source: https://www.houjin-bangou.nta.go.jp/download/
+
+  License: CC BY 4.0
+
+* MJ character table (文字情報技術促進協議会: MJ文字一覧表)
+
+  Publisher: Character Information Technology Promotion Council (CITPC)
+
+  Author: Information-technology Promotion Agency (IPA)
+
+  Source: https://moji.or.jp/mojikiban/mjlist/
+
+  License: CC BY-SA 2.1 JP
+
+* MJ shrink conversion mappings (文字情報技術促進協議会: MJ縮退マップ)
+
+  Publisher: Character Information Technology Promotion Council (CITPC)
+
+  Author: Information-technology Promotion Agency (IPA)
+
+  Source: https://moji.or.jp/mojikiban/map/ 
+
+  License: CC BY-SA 2.1 JP

{jntajis-python-0.0.13 → jntajis_python-0.0.16}/docs/source/conf.py

@@ -15,7 +15,6 @@
 # sys.path.insert(0, os.path.abspath("."))
 from importlib.metadata import version as _version
 
-
 # -- Project information -----------------------------------------------------
 
 project = "jntajis-python"

jntajis_python-0.0.16/pyproject.toml

@@ -0,0 +1,107 @@
+[build-system]
+requires = [
+    "hatchling",
+    "hatch-cython>=0.5.0",
+    "hatch-vcs",
+    "Cython>=3.0.0",
+]
+build-backend = "hatchling.build"
+
+[project]
+name = "jntajis-python"
+description = "A fast character conversion and transliteration library based on the scheme defined for Japan National Tax Agency's corporate number system."
+readme = "README.md"
+license = "BSD-3-Clause"
+requires-python = ">= 3.10"
+authors = [
+    { name = "Open Collector, inc.", email = "info@opencollector.co.jp" },
+]
+keywords = ["Unicode", "JIS", "encoding", "conversion", "transliteration", "Japanese"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Text Processing :: Filters",
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+dev = [
+    "click>=8.3",
+    "ruff>=0.4",
+    "jinja2>=3",
+    "mypy>=1.19",
+    "pytest>=6.2",
+    "sphinx>=4",
+    "sphinx-rtd-theme>=0.5",
+]
+
+[project.urls]
+Homepage = "https://github.com/opencollector/jntajis-python"
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.version.raw-options]
+tag_regex = "^(?P<version>[vV]?\\d+(?:\\.\\d+){0,2}[^\\+]*)(?:\\+.*)?$"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/jntajis"]
+
+[tool.hatch.build.targets.wheel.hooks.cython]
+dependencies = ["hatch-cython>=0.5.0"]
+
+[tool.hatch.build.targets.wheel.hooks.cython.options]
+src = "jntajis"
+includes = ["pythoncapi-compat", "src/jntajis"]
+compile_py = false
+directives = { language_level = 3, cdivision = true, boundscheck = false, wraparound = false, embedsignature = true }
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/",
+    "docs/",
+    "README.md",
+    "LICENSE",
+]
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/jntajis/_version.py"
+
+[tool.ruff]
+line-length = 99
+target-version = "py310"
+src = ["src"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W"]
+ignore = ["E501"]
+
+[tool.hatch.envs.lint]
+features = ["dev"]
+
+[tool.hatch.envs.lint.scripts]
+fix = ["ruff format {args:src}", "ruff check --fix {args:src}"]
+check = ["ruff format --check {args:src}", "ruff check {args:src}", "mypy -p jntajis"]
+
+[tool.hatch.envs.wheels]
+dependencies = ["cibuildwheel>=2"]
+detached = true
+
+[tool.hatch.envs.wheels.scripts]
+build = ["cibuildwheel --output-dir {args:dist}"]
+
+[[tool.hatch.envs.hatch-test.matrix]]
+python = ["3.13", "3.12", "3.11", "3.10"]
+
+[tool.mypy]
+files = "src/"
+
+[tool.cibuildwheel]
+build = ["cp310-*", "cp311-*",  "cp312-*", "cp313-*"]
+# skip = "pp*"
+
+[tool.cibuildwheel.macos]
+archs = ["universal2"]

jntajis_python-0.0.16/pythoncapi-compat/docs/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)