pysinrom 0.1.0__tar.gz

pysinrom-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anonymous Authors
+
+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.

pysinrom-0.1.0/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: pysinrom
+Version: 0.1.0
+Summary: Python tools for Sinitic romanization, currently only as research utilities for conversion between Jyutping and CantRomZJ1
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: OS Independent
+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 :: Linguistic
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pycantonese<6,>=5.0
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Dynamic: license-file
+
+# PySinRom
+
+## Installation
+
+After publication on PyPI:
+
+```bash
+pip install pysinrom
+```
+
+For local installation from the project directory:
+
+```bash
+python -m pip install .
+```
+
+## Usage
+
+```python
+from pysinrom import (
+    jyutping_to_cantromzj1,
+    cantromzj1_to_jyutping,
+)
+
+cantromzj1, syllables = jyutping_to_cantromzj1("hoeng1gong2")
+print(cantromzj1)
+# heong1A|55gong2A|35
+
+jyutping, syllables = cantromzj1_to_jyutping("heong1A|55gong2A|35")
+print(jyutping)
+# hoeng1gong2
+```
+
+Space-separated input and output are also supported:
+
+```python
+result = jyutping_to_cantromzj1(
+    "hoeng1 gong2",
+    output_separator=" ",
+    return_mode="string",
+)
+print(result)
+# heong1A|55 gong2A|35
+```
+
+## Main functions
+
+- `jyutping_to_cantromzj1()`
+- `jyutping_syllable_to_cantromzj1()`
+- `cantromzj1_to_jyutping()`
+- `cantromzj1_syllable_to_jyutping()`
+- `parse_cantromzj1()`
+- `parse_cantromzj1_syllable()`
+
+The default return mode for full-string conversion is a tuple containing the joined output string and a list of converted syllables. Set `return_mode="string"` or `return_mode="list"` to request only one representation.
+
+## Development status
+
+This is research software released as an alpha version. The current implementation focuses on the romanization correspondences described in the accompanying anonymous manuscript.
+
+## License
+
+MIT License.

pysinrom-0.1.0/README.md

@@ -0,0 +1,63 @@
+# PySinRom
+
+## Installation
+
+After publication on PyPI:
+
+```bash
+pip install pysinrom
+```
+
+For local installation from the project directory:
+
+```bash
+python -m pip install .
+```
+
+## Usage
+
+```python
+from pysinrom import (
+    jyutping_to_cantromzj1,
+    cantromzj1_to_jyutping,
+)
+
+cantromzj1, syllables = jyutping_to_cantromzj1("hoeng1gong2")
+print(cantromzj1)
+# heong1A|55gong2A|35
+
+jyutping, syllables = cantromzj1_to_jyutping("heong1A|55gong2A|35")
+print(jyutping)
+# hoeng1gong2
+```
+
+Space-separated input and output are also supported:
+
+```python
+result = jyutping_to_cantromzj1(
+    "hoeng1 gong2",
+    output_separator=" ",
+    return_mode="string",
+)
+print(result)
+# heong1A|55 gong2A|35
+```
+
+## Main functions
+
+- `jyutping_to_cantromzj1()`
+- `jyutping_syllable_to_cantromzj1()`
+- `cantromzj1_to_jyutping()`
+- `cantromzj1_syllable_to_jyutping()`
+- `parse_cantromzj1()`
+- `parse_cantromzj1_syllable()`
+
+The default return mode for full-string conversion is a tuple containing the joined output string and a list of converted syllables. Set `return_mode="string"` or `return_mode="list"` to request only one representation.
+
+## Development status
+
+This is research software released as an alpha version. The current implementation focuses on the romanization correspondences described in the accompanying anonymous manuscript.
+
+## License
+
+MIT License.

pysinrom-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pysinrom"
+version = "0.1.0"
+description = "Python tools for Sinitic romanization, currently only as research utilities for conversion between Jyutping and CantRomZJ1"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = [
+    "pycantonese>=5.0,<6",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Operating System :: OS Independent",
+    "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 :: Linguistic",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=8"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

pysinrom-0.1.0/setup.cfg

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

pysinrom-0.1.0/src/pysinrom/__init__.py

@@ -0,0 +1,28 @@
+"""Bidirectional conversion between Jyutping and CantRomZJ1."""
+
+from .jyutping_to_cantromzj1 import (
+    jyutping_syllable_to_cantromzj1,
+    jyutping_to_cantromzj1,
+    parse_jyutping_to_cantromzj1_objects,
+)
+from .cantromzj1_parse import (
+    parse_cantromzj1,
+    parse_cantromzj1_syllable,
+)
+from .cantromzj1_to_jyutping import (
+    cantromzj1_syllable_to_jyutping,
+    cantromzj1_to_jyutping,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    "jyutping_syllable_to_cantromzj1",
+    "jyutping_to_cantromzj1",
+    "parse_jyutping_to_cantromzj1_objects",
+    "parse_cantromzj1",
+    "parse_cantromzj1_syllable",
+    "cantromzj1_syllable_to_jyutping",
+    "cantromzj1_to_jyutping",
+]

pysinrom-0.1.0/src/pysinrom/cantromzj1_maps.py

@@ -0,0 +1,100 @@
+"""Shared maps for Jyutping <-> CantRomZJ1 conversion."""
+
+from __future__ import annotations
+
+CHECKED_CODAS = {"p", "t", "k"}
+
+# Jyutping nucleus -> CantRomZJ1 nucleus
+JYUTPING_NUCLEUS_TO_CANTROMZJ1 = {
+    "aa": "a",
+    "a": "e",
+    "e": "ea",
+    "oe": "eo",
+    "eo": "oe",
+}
+
+CANTROMZJ1_NUCLEUS_TO_JYUTPING = {
+    value: key for key, value in JYUTPING_NUCLEUS_TO_CANTROMZJ1.items()
+}
+
+# Non-entering tones
+JYUTPING_TONE_TO_CANTROMZJ1_OPEN = {
+    "1": "1A|55",
+    "4": "1B|21",
+    "2": "2A|35",
+    "5": "2B|13",
+    "3": "3A|33",
+    "6": "3B|22",
+}
+
+# Entering tones, identified by checked codas -p, -t, -k
+JYUTPING_TONE_TO_CANTROMZJ1_CHECKED = {
+    "1": "4Aa|5",
+    "3": "4Ab|3",
+    "6": "4B|2",
+}
+
+CANTROMZJ1_TONE_TO_JYUTPING = {
+    "1A|55": "1",
+    "1B|21": "4",
+    "2A|35": "2",
+    "2B|13": "5",
+    "3A|33": "3",
+    "3B|22": "6",
+    "4Aa|5": "1",
+    "4Ab|3": "3",
+    "4B|2": "6",
+}
+
+CANTROMZJ1_TONES = tuple(
+    sorted(CANTROMZJ1_TONE_TO_JYUTPING.keys(), key=len, reverse=True)
+)
+
+# PyCantonese/Jyutping onset inventory.
+# Keep "onset" in the returned PyCantonese Jyutping object because that is the library field name.
+JYUTPING_ONSETS = (
+    "gw", "kw", "ng",
+    "b", "p", "m", "f",
+    "d", "t", "n", "l",
+    "g", "k", "h",
+    "w", "z", "c", "s", "j",
+    "",
+)
+
+JYUTPING_CODAS = ("ng", "p", "t", "k", "m", "n", "i", "u", "")
+
+# Nuclei after Jyutping -> CantRomZJ1 conversion.
+VALID_CANTROMZJ1_NUCLEI = {
+    "a", "e", "ea", "i", "o", "u", "eo", "oe", "yu", "m", "ng"
+}
+
+
+def convert_nucleus_jyutping_to_cantromzj1(nucleus: str) -> str:
+    """Convert one Jyutping nucleus to CantRomZJ1."""
+    return JYUTPING_NUCLEUS_TO_CANTROMZJ1.get(nucleus, nucleus)
+
+
+def convert_nucleus_cantromzj1_to_jyutping(nucleus: str) -> str:
+    """Convert one CantRomZJ1 nucleus back to Jyutping."""
+    return CANTROMZJ1_NUCLEUS_TO_JYUTPING.get(nucleus, nucleus)
+
+
+def convert_tone_jyutping_to_cantromzj1(tone: str, coda: str) -> str:
+    """Convert one Jyutping tone number to CantRomZJ1 tone notation."""
+    if coda in CHECKED_CODAS:
+        tone_map = JYUTPING_TONE_TO_CANTROMZJ1_CHECKED
+    else:
+        tone_map = JYUTPING_TONE_TO_CANTROMZJ1_OPEN
+
+    try:
+        return tone_map[tone]
+    except KeyError as exc:
+        raise ValueError(f"Unsupported Jyutping tone {tone!r} for coda {coda!r}") from exc
+
+
+def convert_tone_cantromzj1_to_jyutping(tone: str) -> str:
+    """Convert one CantRomZJ1 tone notation back to a Jyutping tone number."""
+    try:
+        return CANTROMZJ1_TONE_TO_JYUTPING[tone]
+    except KeyError as exc:
+        raise ValueError(f"Unsupported CantRomZJ1 tone {tone!r}") from exc

pysinrom-0.1.0/src/pysinrom/cantromzj1_parse.py

@@ -0,0 +1,121 @@
+"""Parse CantRomZJ1 strings into PyCantonese-style Jyutping objects."""
+
+from __future__ import annotations
+
+from pycantonese.jyutping import Jyutping
+
+from .cantromzj1_maps import (
+    CANTROMZJ1_TONES,
+    JYUTPING_CODAS,
+    JYUTPING_ONSETS,
+    VALID_CANTROMZJ1_NUCLEI,
+)
+
+
+def _split_cantromzj1_tone(syllable: str) -> tuple[str, str]:
+    """Split one CantRomZJ1 syllable into segmental body and tone notation."""
+    for tone in CANTROMZJ1_TONES:
+        if syllable.endswith(tone):
+            body = syllable[: -len(tone)]
+            if not body:
+                raise ValueError(f"Missing segmental body before tone in {syllable!r}")
+            return body, tone
+    raise ValueError(f"Cannot find a valid CantRomZJ1 tone suffix in {syllable!r}")
+
+
+def _split_body(body: str) -> tuple[str, str, str]:
+    """
+    Split CantRomZJ1 segmental body into onset, nucleus, coda.
+
+    Returned field name in the PyCantonese object is still 'onset',
+    because PyCantonese uses Jyutping(onset=..., nucleus=..., coda=..., tone=...).
+    """
+
+    # Syllabic nasals, e.g. m4 / ng4 after conversion.
+    if body in {"m", "ng"}:
+        return "", body, ""
+
+    for onset in JYUTPING_ONSETS:
+        if onset and not body.startswith(onset):
+            continue
+
+        rest = body[len(onset):] if onset else body
+        if not rest:
+            continue
+
+        for coda in JYUTPING_CODAS:
+            if coda and not rest.endswith(coda):
+                continue
+
+            nucleus = rest[: -len(coda)] if coda else rest
+            if nucleus in VALID_CANTROMZJ1_NUCLEI:
+                return onset, nucleus, coda
+
+    raise ValueError(f"Cannot split CantRomZJ1 syllable body {body!r}")
+
+
+def parse_cantromzj1_syllable(syllable: str) -> Jyutping:
+    """
+    Parse one CantRomZJ1 syllable into a PyCantonese-style Jyutping object.
+
+    Example:
+        parse_cantromzj1_syllable("heong1A|55")
+        -> Jyutping(onset='h', nucleus='eo', coda='ng', tone='1A|55')
+    """
+    body, tone = _split_cantromzj1_tone(syllable.strip())
+    onset, nucleus, coda = _split_body(body)
+    return Jyutping(onset=onset, nucleus=nucleus, coda=coda, tone=tone)
+
+
+def _split_cantromzj1_syllables(text: str) -> list[str]:
+    """
+    Split a concatenated CantRomZJ1 string into syllables by tone suffixes.
+
+    Example:
+        "heong1A|55gong2A|35" -> ["heong1A|55", "gong2A|35"]
+    """
+    text = text.strip()
+    if not text:
+        return []
+
+    if " " in text:
+        return [item for item in text.split() if item]
+
+    syllables: list[str] = []
+    start = 0
+    i = 0
+
+    while i < len(text):
+        matched_tone = None
+        for tone in CANTROMZJ1_TONES:
+            if text.startswith(tone, i):
+                matched_tone = tone
+                break
+
+        if matched_tone is None:
+            i += 1
+            continue
+
+        end = i + len(matched_tone)
+        syllables.append(text[start:end])
+        start = end
+        i = end
+
+    if start != len(text):
+        raise ValueError(f"Unparsed trailing content in CantRomZJ1 string: {text[start:]!r}")
+
+    return syllables
+
+
+def parse_cantromzj1(text: str) -> list[Jyutping]:
+    """
+    Parse a CantRomZJ1 string into PyCantonese-style Jyutping objects.
+
+    Both concatenated and space-separated input are accepted.
+
+    Example:
+        parse_cantromzj1("heong1A|55gong2A|35")
+        -> [Jyutping(onset='h', nucleus='eo', coda='ng', tone='1A|55'),
+            Jyutping(onset='g', nucleus='o', coda='ng', tone='2A|35')]
+    """
+    return [parse_cantromzj1_syllable(syl) for syl in _split_cantromzj1_syllables(text)]

pysinrom-0.1.0/src/pysinrom/cantromzj1_to_jyutping.py

@@ -0,0 +1,71 @@
+"""Convert CantRomZJ1 strings back to Jyutping strings."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from .cantromzj1_maps import (
+    convert_nucleus_cantromzj1_to_jyutping,
+    convert_tone_cantromzj1_to_jyutping,
+)
+from .cantromzj1_parse import parse_cantromzj1, parse_cantromzj1_syllable
+
+
+ReturnMode = Literal["tuple", "string", "list"]
+
+
+def cantromzj1_syllable_to_jyutping(cantromzj1_syllable: str) -> str:
+    """
+    Convert one CantRomZJ1 syllable string to one Jyutping syllable string.
+
+    Example:
+        cantromzj1_syllable_to_jyutping("heong1A|55") -> "hoeng1"
+    """
+    parsed = parse_cantromzj1_syllable(cantromzj1_syllable)
+    nucleus = convert_nucleus_cantromzj1_to_jyutping(parsed.nucleus)
+    tone = convert_tone_cantromzj1_to_jyutping(parsed.tone)
+    return f"{parsed.onset}{nucleus}{parsed.coda}{tone}"
+
+
+def cantromzj1_to_jyutping(
+    cantromzj1: str,
+    *,
+    output_separator: str = "",
+    return_mode: ReturnMode = "tuple",
+) -> str | list[str] | tuple[str, list[str]]:
+    """
+    Convert a CantRomZJ1 string to Jyutping.
+
+    Args:
+        cantromzj1:
+            A CantRomZJ1 string. Both concatenated and space-separated input are accepted.
+        output_separator:
+            Separator used when joining converted syllables. Use "" for concatenated
+            output or " " for space-separated output.
+        return_mode:
+            "tuple": return (joined_string, syllable_list).
+            "string": return only the joined string.
+            "list": return only the list of converted syllables.
+
+    Example:
+        cantromzj1_to_jyutping("heong1A|55gong2A|35")
+        -> ("hoeng1gong2", ["hoeng1", "gong2"])
+    """
+    parsed_items = parse_cantromzj1(cantromzj1)
+    converted = []
+
+    for item in parsed_items:
+        nucleus = convert_nucleus_cantromzj1_to_jyutping(item.nucleus)
+        tone = convert_tone_cantromzj1_to_jyutping(item.tone)
+        converted.append(f"{item.onset}{nucleus}{item.coda}{tone}")
+
+    joined = output_separator.join(converted)
+
+    if return_mode == "tuple":
+        return joined, converted
+    if return_mode == "string":
+        return joined
+    if return_mode == "list":
+        return converted
+
+    raise ValueError("return_mode must be one of: 'tuple', 'string', 'list'")

pysinrom-0.1.0/src/pysinrom/jyutping_to_cantromzj1.py

@@ -0,0 +1,97 @@
+"""Convert Jyutping strings to CantRomZJ1 strings or PyCantonese-style objects."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+import pycantonese
+from pycantonese.jyutping import Jyutping
+
+from .cantromzj1_maps import (
+    convert_nucleus_jyutping_to_cantromzj1,
+    convert_tone_jyutping_to_cantromzj1,
+)
+
+
+ReturnMode = Literal["tuple", "string", "list"]
+
+
+def _convert_parsed_jyutping_to_cantromzj1(parsed: Jyutping) -> tuple[str, Jyutping]:
+    """Convert one parsed PyCantonese Jyutping object to CantRomZJ1."""
+    initial = parsed.onset
+    nucleus = convert_nucleus_jyutping_to_cantromzj1(parsed.nucleus)
+    coda = parsed.coda
+    tone = convert_tone_jyutping_to_cantromzj1(parsed.tone, coda)
+
+    syllable = f"{initial}{nucleus}{coda}{tone}"
+    obj = Jyutping(onset=initial, nucleus=nucleus, coda=coda, tone=tone)
+    return syllable, obj
+
+
+def parse_jyutping_to_cantromzj1_objects(jyutping: str) -> list[Jyutping]:
+    """
+    Convert a Jyutping string into PyCantonese-style Jyutping objects,
+    but with CantRomZJ1-style nucleus and tone fields.
+
+    Example:
+        parse_jyutping_to_cantromzj1_objects("hoeng1gong2")
+        -> [Jyutping(onset='h', nucleus='eo', coda='ng', tone='1A|55'), ...]
+    """
+    parsed_items = pycantonese.parse_jyutping(jyutping.replace(" ", ""))
+    return [_convert_parsed_jyutping_to_cantromzj1(item)[1] for item in parsed_items]
+
+
+def jyutping_syllable_to_cantromzj1(jyutping_syllable: str) -> str:
+    """Convert one Jyutping syllable to one CantRomZJ1 syllable string."""
+    parsed_items = pycantonese.parse_jyutping(jyutping_syllable.strip())
+    if len(parsed_items) != 1:
+        raise ValueError(
+            f"Expected exactly one Jyutping syllable, got {len(parsed_items)}: "
+            f"{jyutping_syllable!r}"
+        )
+    return _convert_parsed_jyutping_to_cantromzj1(parsed_items[0])[0]
+
+
+def jyutping_to_cantromzj1(
+    jyutping: str,
+    *,
+    output_separator: str = "",
+    return_mode: ReturnMode = "tuple",
+) -> str | list[str] | tuple[str, list[str]]:
+    """
+    Convert a Jyutping string to CantRomZJ1.
+
+    Args:
+        jyutping:
+            A Jyutping string. Both concatenated and space-separated input are accepted,
+            e.g. "hoeng1gong2" or "hoeng1 gong2".
+        output_separator:
+            Separator used when joining converted syllables. Use "" for concatenated
+            output or " " for space-separated output.
+        return_mode:
+            "tuple": return (joined_string, syllable_list), matching the old behavior.
+            "string": return only the joined string.
+            "list": return only the list of converted syllables.
+
+    Example:
+        jyutping_to_cantromzj1("hoeng1gong2")
+        -> ("heong1A|55gong2A|35", ["heong1A|55", "gong2A|35"])
+
+        jyutping_to_cantromzj1("hoeng1gong2", output_separator=" ", return_mode="string")
+        -> "heong1A|55 gong2A|35"
+    """
+    parsed_items = pycantonese.parse_jyutping(jyutping.replace(" ", ""))
+    converted = [
+        _convert_parsed_jyutping_to_cantromzj1(item)[0]
+        for item in parsed_items
+    ]
+    joined = output_separator.join(converted)
+
+    if return_mode == "tuple":
+        return joined, converted
+    if return_mode == "string":
+        return joined
+    if return_mode == "list":
+        return converted
+
+    raise ValueError("return_mode must be one of: 'tuple', 'string', 'list'")

pysinrom-0.1.0/src/pysinrom.egg-info/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: pysinrom
+Version: 0.1.0
+Summary: Python tools for Sinitic romanization, currently only as research utilities for conversion between Jyutping and CantRomZJ1
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: OS Independent
+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 :: Linguistic
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pycantonese<6,>=5.0
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Dynamic: license-file
+
+# PySinRom
+
+## Installation
+
+After publication on PyPI:
+
+```bash
+pip install pysinrom
+```
+
+For local installation from the project directory:
+
+```bash
+python -m pip install .
+```
+
+## Usage
+
+```python
+from pysinrom import (
+    jyutping_to_cantromzj1,
+    cantromzj1_to_jyutping,
+)
+
+cantromzj1, syllables = jyutping_to_cantromzj1("hoeng1gong2")
+print(cantromzj1)
+# heong1A|55gong2A|35
+
+jyutping, syllables = cantromzj1_to_jyutping("heong1A|55gong2A|35")
+print(jyutping)
+# hoeng1gong2
+```
+
+Space-separated input and output are also supported:
+
+```python
+result = jyutping_to_cantromzj1(
+    "hoeng1 gong2",
+    output_separator=" ",
+    return_mode="string",
+)
+print(result)
+# heong1A|55 gong2A|35
+```
+
+## Main functions
+
+- `jyutping_to_cantromzj1()`
+- `jyutping_syllable_to_cantromzj1()`
+- `cantromzj1_to_jyutping()`
+- `cantromzj1_syllable_to_jyutping()`
+- `parse_cantromzj1()`
+- `parse_cantromzj1_syllable()`
+
+The default return mode for full-string conversion is a tuple containing the joined output string and a list of converted syllables. Set `return_mode="string"` or `return_mode="list"` to request only one representation.
+
+## Development status
+
+This is research software released as an alpha version. The current implementation focuses on the romanization correspondences described in the accompanying anonymous manuscript.
+
+## License
+
+MIT License.

pysinrom-0.1.0/src/pysinrom.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/pysinrom/__init__.py
+src/pysinrom/cantromzj1_maps.py
+src/pysinrom/cantromzj1_parse.py
+src/pysinrom/cantromzj1_to_jyutping.py
+src/pysinrom/jyutping_to_cantromzj1.py
+src/pysinrom.egg-info/PKG-INFO
+src/pysinrom.egg-info/SOURCES.txt
+src/pysinrom.egg-info/dependency_links.txt
+src/pysinrom.egg-info/requires.txt
+src/pysinrom.egg-info/top_level.txt
+tests/test_conversion.py

pysinrom-0.1.0/src/pysinrom.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pysinrom-0.1.0/src/pysinrom.egg-info/requires.txt

@@ -0,0 +1,4 @@
+pycantonese<6,>=5.0
+
+[test]
+pytest>=8

pysinrom-0.1.0/src/pysinrom.egg-info/top_level.txt

@@ -0,0 +1 @@
+pysinrom

pysinrom-0.1.0/tests/test_conversion.py

@@ -0,0 +1,37 @@
+import pytest
+
+from pysinrom import (
+    cantromzj1_syllable_to_jyutping,
+    cantromzj1_to_jyutping,
+    jyutping_syllable_to_cantromzj1,
+    jyutping_to_cantromzj1,
+)
+
+
+def test_jyutping_to_cantromzj1_default_tuple():
+    joined, syllables = jyutping_to_cantromzj1("hoeng1gong2")
+    assert joined == "heong1A|55gong2A|35"
+    assert syllables == ["heong1A|55", "gong2A|35"]
+
+
+def test_cantromzj1_to_jyutping_default_tuple():
+    joined, syllables = cantromzj1_to_jyutping("heong1A|55gong2A|35")
+    assert joined == "hoeng1gong2"
+    assert syllables == ["hoeng1", "gong2"]
+
+
+def test_space_separated_conversion():
+    result = jyutping_to_cantromzj1(
+        "hoeng1 gong2", output_separator=" ", return_mode="string"
+    )
+    assert result == "heong1A|55 gong2A|35"
+
+
+def test_single_syllable_conversion():
+    assert jyutping_syllable_to_cantromzj1("hoeng1") == "heong1A|55"
+    assert cantromzj1_syllable_to_jyutping("heong1A|55") == "hoeng1"
+
+
+def test_invalid_return_mode():
+    with pytest.raises(ValueError):
+        jyutping_to_cantromzj1("hoeng1", return_mode="invalid")