mlinflect 0.0.1__tar.gz

mlinflect-0.0.1/.gitignore

@@ -0,0 +1,11 @@
+# Python
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+build/
+dist/

mlinflect-0.0.1/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

mlinflect-0.0.1/LIMITATIONS.md

@@ -0,0 +1,66 @@
+# Limitations
+
+mlsynth never emits a wrong form. When it cannot produce a form it has not verified,
+it raises instead. Two exception types:
+
+- **`UnsupportedRoot`**: the root's shape is not in a supported noun class.
+- **`NotImplementedError`**: a supported class, but that case/number is not encoded.
+
+This document is generated from the current rules.
+
+## Supported noun classes
+
+| Class | Shape | Example | Coverage |
+|-------|-------|---------|----------|
+| `am_neuter` | consonant + anuswara | `മരം` | complete (11 cases, sg + pl) |
+| `i_vowel` | `-ി` vowel-final | `കുട്ടി` | complete (11 cases, sg + pl) |
+| `u_vowel` | `-ഉ` / `-ഊ` vowel-final | `പശു` | complete singular; plural extrapolated |
+| `vowel_anuswara` | vowel + anuswara | `കലാം`, `ടീം` | singular minus instrumental; no plural |
+| `ṭ_geminate` | `-ട്` final (geminating) | `വീട്` | singular minus instrumental; no plural |
+
+## A. Root shapes that raise `UnsupportedRoot`
+
+These classes are not encoded yet:
+
+| Root shape | Examples | Planned class |
+|------------|----------|---------------|
+| `-അ` / `-എ` vowel stems | `അമ്മ`, `പുഴ` | a/e-stem (`യ` glide) |
+| chillu final | `അവൻ`, `നായർ`, `പാൽ`, `മകൾ` | chillu classes (per-chillu) |
+| long `-ീ` vowel stems | `സ്ത്രീ` | a/e/ī-stem (`യ` glide) |
+| no Malayalam base letter, or empty | `ABC`, `123`, bare signs, `""` | rejected by design |
+
+The a/e-stem class needs predicate-based matching (those roots end in a bare consonant,
+not a fixed suffix); the chillu classes need per-chillu handling. Both are specced and
+deferred to the next release.
+
+## B. Case/number combinations that raise `NotImplementedError`
+
+- **`vowel_anuswara`** (`കലാം`): instrumental and the whole plural are not encoded.
+- **`ṭ_geminate`** (`വീട്`): instrumental and the whole plural are not encoded.
+
+`am_neuter`, `i_vowel`, and `u_vowel` (singular) have no such gaps.
+
+## C. Produced but not native-ratified (`verified=False`)
+
+- **`u_vowel` plural**: the `-ക്കൾ` marker is native-given (`പശുക്കൾ`), but the plural
+  oblique paradigm (`പശുക്കളുടെ`, ...) is extrapolated. Gate on `result.verified` for
+  ratified output only.
+
+## D. Known matching caveat
+
+`u_vowel` matches any root ending in `-ു` / `-ൂ`. A non-standard input that writes a
+final samvruthokaram (half-u) as a bare `-ു` instead of `-്` could be mis-routed here.
+Standard orthography writes samvruthokaram with the virama, so genuine `-ഉ`-final nouns
+(`പശു`, `ഗുരു`) inflect correctly; the risk is limited to non-standard/transliterated input.
+
+## E. Out of scope in this release
+
+- **Verbs**: noun synthesis only; verb synthesis is the next major addition.
+- **Pronouns**: irregular; deferred.
+- **Derivation, compounding, and external sandhi** (word + word) are out of scope.
+
+## Roadmap
+
+Next: the a/e-stem and chillu classes (section A), the instrumental + plural of the
+two partial classes (section B), and native ratification of the `u_vowel` plural.
+Verbs follow as 0.1.0.

mlinflect-0.0.1/NOTICE

@@ -0,0 +1,9 @@
+mlsynth
+Copyright 2026 Jayashankar R
+
+This product includes software developed for permissive, rule-based Malayalam
+morphological synthesis.
+
+Linguistic rules implemented here are restated facts drawn from published
+scholarship (see REFERENCES.md). No third-party text, tables, code, or datasets
+are included or redistributed.

mlinflect-0.0.1/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: mlinflect
+Version: 0.0.1
+Summary: Permissive, rule-based Malayalam morphological synthesizer (noun inflection generation).
+Project-URL: Homepage, https://github.com/jayashankarvr/mlinflect
+Project-URL: Source, https://github.com/jayashankarvr/mlinflect
+Project-URL: Issues, https://github.com/jayashankarvr/mlinflect/issues
+Author-email: Jayashankar R <56070307+jayashankarvr@users.noreply.github.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: agglutinative,dravidian,inflection,malayalam,morphology,nlp,synthesis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# mlinflect
+
+A permissive, rule-based Malayalam morphological synthesizer. It does forward
+morphological generation: given a root and grammatical features, it produces the
+inflected surface form (the counterpart to morphological analysis/segmentation).
+
+```python
+from mlinflect import synthesize_noun, Case, Number
+
+synthesize_noun("മരം", Case.LOCATIVE).surface          # 'മരത്തിൽ'
+synthesize_noun("മരം", Case.GENITIVE).surface          # 'മരത്തിന്റെ'
+synthesize_noun("കുട്ടി", Case.GENITIVE).surface        # 'കുട്ടിയുടെ'
+synthesize_noun("മരം", Case.NOMINATIVE, number=Number.PLURAL).surface  # 'മരങ്ങൾ'
+```
+
+## Why this exists
+
+Existing Malayalam morphology tools are either copyleft (Apertium, libindic =
+GPL/AGPL) or, in the case of the one permissive *generator* (`mlmorph`, MIT), built
+on a GPL FST runtime. There is no permissive, dependency-clean, rule-based Malayalam
+**synthesizer**. `mlinflect` aims to fill that gap with a small pure-Python rule engine
+and no copyleft dependencies.
+
+## Design
+
+- **Declarative, provenance-tagged rules** (`mlinflect/rules.py`): each rule cites the
+  source it was drawn from and carries a `verified` flag that is `True` only when the
+  form has been ratified by a native reviewer. Adding or correcting a paradigm is a
+  data edit, not a code change.
+- **Inspectable results**: every `synthesize_noun(...)` returns a `SynthResult` with the
+  `surface` form, the `morphemes` that compose it, the `stem_class`, the `provenance`
+  key, and `verified`. Feature combinations that are not yet encoded raise rather than
+  return a silently wrong form.
+- **Akshara-correct joins**: suffixes are represented matra-initial so concatenation
+  produces correct conjuncts/vowel signs; the genitive uses the canonical *nta* form
+  (NA + virama + RRA).
+
+## Status
+
+Alpha. Five ending-conditioned noun classes: `am_neuter` (മരം) and `i_vowel` (കുട്ടി)
+are complete across 11 cases (singular and plural); `vowel_anuswara` (കലാം), `u_vowel`
+(പശു), and `ṭ_geminate` (വീട്) are partial. Includes differential object marking and a
+synthetic/colloquial register for the instrumental. Most forms are native-ratified
+(`verified=True`); a few are SMC-sourced pending sign-off (`verified=False`). See
+[`LIMITATIONS.md`](LIMITATIONS.md) for exactly what is unsupported. Remaining noun
+classes (a/e-stems, chillu), verbs, and pronouns are future work.
+
+## Install
+
+```bash
+pip install mlinflect        # once published
+# from source:
+pip install -e ".[dev]"
+```
+
+## License
+
+Apache-2.0. See `LICENSE` and `NOTICE`. Contributions are accepted under Apache-2.0
+§5 (inbound = outbound); no separate CLA is required.
+
+The implemented linguistic rules are **facts** restated in our own code; no source's
+text, tables, code, or data is reproduced. Sources are credited in `REFERENCES.md` as
+scholarship; that implies no endorsement and creates no license obligation.

mlinflect-0.0.1/README.md

@@ -0,0 +1,63 @@
+# mlinflect
+
+A permissive, rule-based Malayalam morphological synthesizer. It does forward
+morphological generation: given a root and grammatical features, it produces the
+inflected surface form (the counterpart to morphological analysis/segmentation).
+
+```python
+from mlinflect import synthesize_noun, Case, Number
+
+synthesize_noun("മരം", Case.LOCATIVE).surface          # 'മരത്തിൽ'
+synthesize_noun("മരം", Case.GENITIVE).surface          # 'മരത്തിന്റെ'
+synthesize_noun("കുട്ടി", Case.GENITIVE).surface        # 'കുട്ടിയുടെ'
+synthesize_noun("മരം", Case.NOMINATIVE, number=Number.PLURAL).surface  # 'മരങ്ങൾ'
+```
+
+## Why this exists
+
+Existing Malayalam morphology tools are either copyleft (Apertium, libindic =
+GPL/AGPL) or, in the case of the one permissive *generator* (`mlmorph`, MIT), built
+on a GPL FST runtime. There is no permissive, dependency-clean, rule-based Malayalam
+**synthesizer**. `mlinflect` aims to fill that gap with a small pure-Python rule engine
+and no copyleft dependencies.
+
+## Design
+
+- **Declarative, provenance-tagged rules** (`mlinflect/rules.py`): each rule cites the
+  source it was drawn from and carries a `verified` flag that is `True` only when the
+  form has been ratified by a native reviewer. Adding or correcting a paradigm is a
+  data edit, not a code change.
+- **Inspectable results**: every `synthesize_noun(...)` returns a `SynthResult` with the
+  `surface` form, the `morphemes` that compose it, the `stem_class`, the `provenance`
+  key, and `verified`. Feature combinations that are not yet encoded raise rather than
+  return a silently wrong form.
+- **Akshara-correct joins**: suffixes are represented matra-initial so concatenation
+  produces correct conjuncts/vowel signs; the genitive uses the canonical *nta* form
+  (NA + virama + RRA).
+
+## Status
+
+Alpha. Five ending-conditioned noun classes: `am_neuter` (മരം) and `i_vowel` (കുട്ടി)
+are complete across 11 cases (singular and plural); `vowel_anuswara` (കലാം), `u_vowel`
+(പശു), and `ṭ_geminate` (വീട്) are partial. Includes differential object marking and a
+synthetic/colloquial register for the instrumental. Most forms are native-ratified
+(`verified=True`); a few are SMC-sourced pending sign-off (`verified=False`). See
+[`LIMITATIONS.md`](LIMITATIONS.md) for exactly what is unsupported. Remaining noun
+classes (a/e-stems, chillu), verbs, and pronouns are future work.
+
+## Install
+
+```bash
+pip install mlinflect        # once published
+# from source:
+pip install -e ".[dev]"
+```
+
+## License
+
+Apache-2.0. See `LICENSE` and `NOTICE`. Contributions are accepted under Apache-2.0
+§5 (inbound = outbound); no separate CLA is required.
+
+The implemented linguistic rules are **facts** restated in our own code; no source's
+text, tables, code, or data is reproduced. Sources are credited in `REFERENCES.md` as
+scholarship; that implies no endorsement and creates no license obligation.

mlinflect-0.0.1/REFERENCES.md

@@ -0,0 +1,40 @@
+# References
+
+`mlsynth` implements Malayalam morphological **facts** (case-marker allomorphy,
+oblique-stem augments, glide insertion) restated in our own rule engine. **No text,
+tables, code, or datasets from any source below are reproduced or redistributed.**
+These citations are scholarly credit; they imply no endorsement and create no license
+obligation.
+
+Each rule in `mlsynth/rules.py` carries a `provenance` key from this list. Forms are
+ratified through a native-reviewer workflow; a rule's `verified` flag is `True` only
+after native sign-off.
+
+## Provenance keys
+
+- **`vinod-2012`**: Vinod P. M., Jayan V., Bhadran V. K. *Implementation of Malayalam
+  Morphological Analyzer Based on Hybrid Approach.* Proc. ROCLING 2012 (ACL Anthology
+  O12-1028). Source of the `am_neuter` (-ം, oblique -ത്ത-) singular paradigm.
+- **`krishnan-2021`**: Krishnan G. G., Raghunathan A., Sarma V. M. *Acquisition of
+  Malayalam inflections: Complexity of morphosyntactic rules and its impact on
+  developing grammars.* First Language. Case inventory and allomorphy for the
+  `i_vowel` class.
+- **`native-14`**: Native-reviewer ratification (project correctness log, item #14):
+  the modern genitive form കുട്ടിയുടെ (over the archaic FST form).
+- **`native-2026`**: Native-reviewer worksheet ratification of the മരം and കുട്ടി
+  singular/plural paradigms, the differential-object-marking rule (inanimate accusative
+  defaults bare), and the synthetic/analytic instrumental register.
+- **`smc-morph`**: SMC's Malayalam morphology documentation, covering nominal inflection rules
+  (https://morph.smc.org.in/ninfl/cases.html) and the mlmorph tagset
+  (https://gitlab.com/smc/mlmorph). Used for cases pending native sign-off
+  (ablative, allative, perlative, vocative). Rules restated as facts, no data copied.
+
+## Additional background consulted (facts only)
+
+- Gayathri G. Krishnan. *Malayalam Morphosyntax: Inflectional Features and their
+  Acquisition.* PhD thesis, IIT Bombay, 2019.
+- Premjith B., Soman K. P. *Deep Learning Approach for the Morphological Synthesis in
+  Malayalam and Tamil at the Character Level.* ACM TALLIP 20(6), 2021. (Framing of
+  synthesis as morpheme-boundary transformation.)
+- Kunjamma S. *Lexical and Grammatical Meaning in Malayalam.* Language in India, 2019.
+  (Case-role semantics; positive/negative verb opposition.)

mlinflect-0.0.1/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mlinflect"
+version = "0.0.1"
+description = "Permissive, rule-based Malayalam morphological synthesizer (noun inflection generation)."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "Apache-2.0"
+license-files = ["LICENSE", "NOTICE"]
+authors = [{ name = "Jayashankar R", email = "56070307+jayashankarvr@users.noreply.github.com" }]
+keywords = ["malayalam", "morphology", "nlp", "inflection", "dravidian", "agglutinative", "synthesis"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Topic :: Text Processing :: Linguistic",
+    "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://github.com/jayashankarvr/mlinflect"
+Source = "https://github.com/jayashankarvr/mlinflect"
+Issues = "https://github.com/jayashankarvr/mlinflect/issues"
+
+[project.optional-dependencies]
+dev = ["pytest>=7"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mlinflect"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

mlinflect-0.0.1/src/mlinflect/__init__.py

@@ -0,0 +1,26 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Jayashankar R
+"""A permissive, rule-based Malayalam morphological synthesizer.
+
+Forward morphological generation (root + features -> inflected surface form),
+starting with noun inflection. Rules are declarative and provenance-tagged; see
+REFERENCES.md for the linguistic sources and the project's native-ratification
+workflow.
+"""
+from .nouns import UnsupportedRoot, list_supported_classes, synthesize_noun
+from .types import Animacy, Case, Gender, NounFeatures, Number, Register, SynthResult
+
+__version__ = "0.0.1"
+__all__ = [
+    "Animacy",
+    "Case",
+    "Gender",
+    "Number",
+    "NounFeatures",
+    "Register",
+    "SynthResult",
+    "synthesize_noun",
+    "list_supported_classes",
+    "UnsupportedRoot",
+    "__version__",
+]

mlinflect-0.0.1/src/mlinflect/nouns.py

@@ -0,0 +1,176 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Jayashankar R
+"""Rule-based Malayalam noun synthesis: (root + features) -> inflected surface form.
+
+The forward (generation) counterpart to morphological analysis, applying the
+ending-conditioned rules in :mod:`mlsynth.rules`. Every result carries the rule's
+provenance and a ``verified`` flag (true only for native-ratified forms).
+
+Two cross-cutting rules from the native review / SMC docs:
+  * Differential object marking (DOM): an inanimate noun's accusative defaults to the
+    bare form (മരം), the overt form (മരത്തെ) only on request; an animate noun's
+    accusative is always overt.
+  * Register: the instrumental is synthetic by default (മരത്താൽ) but analytic in the
+    colloquial register (മരം കൊണ്ട്).
+"""
+from __future__ import annotations
+
+from typing import List, Optional
+
+from .rules import CLASSES, NounClass
+from .types import Animacy, Case, Gender, NounFeatures, Number, Register, SynthResult
+
+# Chillu -> base consonant (a chillu reverts before a following vowel sign).
+_CHILLU_BASE = {
+    "ൺ": "ണ", "ൻ": "ന", "ർ": "ര", "ൽ": "ല", "ൾ": "ള", "ൿ": "ക",
+}
+
+
+def _is_vowel_sign(ch: str) -> bool:
+    o = ord(ch)
+    return 0x0D3E <= o <= 0x0D4C or o in (0x0D57, 0x0D62, 0x0D63)
+
+
+def _is_independent_vowel(ch: str) -> bool:
+    o = ord(ch)
+    return 0x0D05 <= o <= 0x0D14 or o in (0x0D60, 0x0D61)
+
+
+def _attach(stem: str, suffix: str) -> str:
+    """Join a matra-initial suffix to a stem, reverting a trailing chillu to its base."""
+    if not suffix:
+        return stem
+    if stem and _is_vowel_sign(suffix[0]) and stem[-1] in _CHILLU_BASE:
+        stem = stem[:-1] + _CHILLU_BASE[stem[-1]]
+    return stem + suffix
+
+
+class UnsupportedRoot(ValueError):
+    """No noun class matches the root and none was given explicitly."""
+
+
+def list_supported_classes() -> List[str]:
+    return sorted(CLASSES)
+
+
+def _has_base_letter(s: str) -> bool:
+    # Reject input made only of signs/virama/anusvara or non-Malayalam text.
+    return any("അ" <= ch <= "ഺ" for ch in s)
+
+
+def _class_matches(cls: NounClass, root: str) -> bool:
+    for e in cls.endings:
+        if root.endswith(e):
+            if cls.pre:
+                pre = root[: -len(e)]
+                if not pre:
+                    return False
+                is_vowel = _is_vowel_sign(pre[-1]) or _is_independent_vowel(pre[-1])
+                # consonant+anuswara (മരം) vs vowel+anuswara (കലാം, ഓം): same ending,
+                # disambiguated by what precedes it.
+                if cls.pre == "consonant" and is_vowel:
+                    return False
+                if cls.pre == "vowel" and not is_vowel:
+                    return False
+            return True
+    return False
+
+
+def _resolve_class(root: str, stem_class: Optional[str]) -> NounClass:
+    if stem_class is not None:
+        try:
+            cls = CLASSES[stem_class]
+        except KeyError:
+            raise UnsupportedRoot(
+                f"unknown stem_class {stem_class!r}; supported: {list_supported_classes()}"
+            ) from None
+        if not _class_matches(cls, root):
+            raise UnsupportedRoot(
+                f"root {root!r} does not fit class {cls.name!r} (endings {cls.endings}"
+                + (f", {cls.pre}-stem only)" if cls.pre else ")")
+            )
+        return cls
+    for cls in sorted(
+        CLASSES.values(), key=lambda c: max(len(e) for e in c.endings), reverse=True
+    ):
+        if _class_matches(cls, root):
+            return cls
+    raise UnsupportedRoot(
+        f"cannot infer a noun class for root {root!r}; pass stem_class= explicitly "
+        f"(supported: {list_supported_classes()})"
+    )
+
+
+def synthesize_noun(
+    root: str,
+    case: Case,
+    number: Number = Number.SINGULAR,
+    *,
+    animacy: Optional[Animacy] = None,
+    register: Register = Register.FORMAL,
+    gender: Optional[Gender] = None,
+    stem_class: Optional[str] = None,
+    marked: bool = False,
+) -> SynthResult:
+    """Generate the inflected surface form of ``root`` for the given features.
+
+    ``animacy`` drives DOM (accusative) and is recorded on the result; with it unknown,
+    the accusative defaults to the overt form. ``marked=True`` forces the overt
+    accusative for an inanimate noun. ``gender`` is recorded but unused by current
+    classes. Unencoded feature combinations raise :class:`NotImplementedError`;
+    unresolvable/ill-formed roots raise :class:`UnsupportedRoot`. Never a silently
+    wrong form.
+    """
+    if not root:
+        raise UnsupportedRoot("root must be a non-empty string")
+    if not _has_base_letter(root):
+        raise UnsupportedRoot(f"root {root!r} contains no Malayalam base letter")
+    cls = _resolve_class(root, stem_class)
+    features = NounFeatures(
+        case=case, number=number, animacy=animacy, register=register, gender=gender
+    )
+
+    def _result(surface, morphemes, provenance, verified, analytic=False):
+        return SynthResult(
+            surface=surface, root=root, features=features, morphemes=morphemes,
+            stem_class=cls.name, provenance=provenance, verified=verified, analytic=analytic,
+        )
+
+    table = cls.plural_cases if number is Number.PLURAL else cls.cases
+    try:
+        rule = table[case]
+    except KeyError:
+        raise NotImplementedError(
+            f"case {case.value!r} ({number.value}) not yet encoded for class {cls.name!r}"
+        ) from None
+
+    # The nominative form of the requested number (used by DOM and the analytic register).
+    nom_rule = table[Case.NOMINATIVE]
+    nom_stem = (cls.plural_marker.apply(root) if number is Number.PLURAL else root)
+    nominative = _attach(nom_stem, nom_rule.suffix) if nom_rule.use_oblique else nom_stem
+
+    # Colloquial instrumental is analytic (nominative + കൊണ്ട്); verified/provenance
+    # track the nominative, so non-ratified inputs aren't over-claimed (worksheet Q2).
+    if case is Case.INSTRUMENTAL and register is Register.COLLOQUIAL:
+        return _result(nominative + " കൊണ്ട്", [nominative, "കൊണ്ട്"],
+                       nom_rule.provenance, nom_rule.verified, analytic=True)
+
+    # DOM: inanimate accusative is the bare nominative (worksheet Q1); inherits its flags.
+    if case is Case.ACCUSATIVE and animacy is Animacy.INANIMATE and not marked:
+        return _result(nominative, [nominative], nom_rule.provenance, nom_rule.verified)
+
+    if number is Number.PLURAL:
+        stem = cls.plural_marker.apply(root)
+        surface = _attach(stem, rule.suffix)
+        morphemes = [stem, rule.suffix] if rule.suffix else [stem]
+        return _result(surface, morphemes, rule.provenance, rule.verified)
+
+    if rule.oblique is not None:
+        stem = rule.oblique.apply(root)       # per-case stem (e.g. ട് gemination)
+    elif rule.use_oblique:
+        stem = cls.oblique.apply(root)
+    else:
+        stem = root
+    surface = _attach(stem, rule.suffix)
+    morphemes = [stem, rule.suffix] if rule.suffix else [stem]
+    return _result(surface, morphemes, rule.provenance, rule.verified)

mlinflect-0.0.1/src/mlinflect/rules.py

@@ -0,0 +1,199 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Jayashankar R
+"""Declarative, provenance-tagged noun-inflection rules, conditioned on stem ending.
+
+A noun class is selected by the root's ending (anuswara `ം`, vowel sign `ി`/`ു`, the
+`ട്` cluster, ...) plus an optional `pre` constraint (whether a consonant or a vowel
+precedes the ending). Each class supplies an oblique-stem transform and a matra-initial
+suffix per case; a case may override the stem (e.g. `ട്` geminates only for the spatial
+cases). Suffixes attach via ``nouns._attach``, which reverts a trailing chillu to its
+base consonant before a vowel sign (so plural മരങ്ങൾ + `ുടെ` → മരങ്ങളുടെ).
+
+Provenance keys (see REFERENCES.md): ``native-2026`` (native-ratified), ``smc-morph``
+(SMC docs, pending native sign-off), ``native-14`` (genitive #14). Editing a paradigm
+is a data edit here; flip ``verified`` after native sign-off.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Optional, Tuple
+
+from .types import Case
+
+
+@dataclass(frozen=True)
+class StemTransform:
+    strip: str
+    append: str
+
+    def apply(self, root: str) -> str:
+        if self.strip and root.endswith(self.strip):
+            root = root[: -len(self.strip)]
+        return root + self.append
+
+
+@dataclass(frozen=True)
+class CaseRule:
+    suffix: str        # matra-initial; "" for the bare nominative
+    use_oblique: bool  # attach to the class oblique stem (True) or the bare root (False)
+    provenance: str
+    verified: bool = False
+    oblique: Optional[StemTransform] = None  # per-case stem override (e.g. ട് gemination)
+
+
+@dataclass(frozen=True)
+class NounClass:
+    name: str
+    description: str
+    endings: Tuple[str, ...]
+    oblique: StemTransform
+    cases: Dict[Case, CaseRule]
+    plural_marker: StemTransform
+    plural_cases: Dict[Case, CaseRule]
+    # "" = match on ending alone; "consonant"/"vowel" = also require that kind of
+    # character before the ending (disambiguates മരം consonant+anuswara from കലാം
+    # vowel+anuswara, both ending in ം).
+    pre: str = ""
+
+
+# ട് gemination, shared by the spatial cases of the ṭ_geminate class.
+_GEMINATE_T = StemTransform("ട്", "ട്ട")
+
+
+# Plural case markers attach to the plural stem (its trailing chillu ൾ reverts to ള
+# before a vowel sign). Includes vocative -ഏ (worksheet Part B). Provenance/verified
+# are per-class.
+def _plural_cases(provenance: str, verified: bool) -> Dict[Case, CaseRule]:
+    v = verified
+    return {
+        Case.NOMINATIVE: CaseRule("", False, provenance, v),
+        Case.ACCUSATIVE: CaseRule("െ", True, provenance, v),
+        Case.DATIVE: CaseRule("ക്ക്", True, provenance, v),
+        Case.GENITIVE: CaseRule("ുടെ", True, provenance, v),
+        Case.SOCIATIVE: CaseRule("ോട്", True, provenance, v),
+        Case.LOCATIVE: CaseRule("ിൽ", True, provenance, v),
+        Case.INSTRUMENTAL: CaseRule("ാൽ", True, provenance, v),
+        Case.VOCATIVE: CaseRule("േ", True, provenance, v),
+        Case.ABLATIVE: CaseRule("ിൽനിന്ന്", True, provenance, v),
+        Case.ALLATIVE: CaseRule("ിലേക്ക്", True, provenance, v),
+        Case.PERLATIVE: CaseRule("ിലൂടെ", True, provenance, v),
+    }
+
+
+CLASSES: Dict[str, NounClass] = {
+    # Consonant + anuswara (e.g. മരം); oblique augment -ത്ത-. Vocative uses a -മ- stem
+    # (മരം -> മരമേ). Core cases native-ratified; abl/all/perl ratified in worksheet C.
+    "am_neuter": NounClass(
+        name="am_neuter",
+        description="Consonant + anuswara nouns (e.g. മരം 'tree'); oblique augment -ത്ത-.",
+        endings=("ം",),
+        pre="consonant",
+        oblique=StemTransform("ം", "ത്ത"),
+        cases={
+            Case.NOMINATIVE: CaseRule("", False, "native-2026", True),
+            Case.ACCUSATIVE: CaseRule("െ", True, "native-2026", True),
+            Case.DATIVE: CaseRule("ിന്", True, "native-2026", True),
+            Case.GENITIVE: CaseRule("ിന്റെ", True, "native-2026", True),
+            Case.SOCIATIVE: CaseRule("ോട്", True, "native-2026", True),
+            Case.LOCATIVE: CaseRule("ിൽ", True, "native-2026", True),
+            Case.INSTRUMENTAL: CaseRule("ാൽ", True, "native-2026", True),
+            Case.VOCATIVE: CaseRule("േ", False, "native-2026", True, oblique=StemTransform("ം", "മ")),
+            Case.ABLATIVE: CaseRule("ിൽനിന്ന്", True, "native-2026", True),
+            Case.ALLATIVE: CaseRule("ിലേക്ക്", True, "native-2026", True),
+            Case.PERLATIVE: CaseRule("ിലൂടെ", True, "native-2026", True),
+        },
+        plural_marker=StemTransform("ം", "ങ്ങൾ"),
+        plural_cases=_plural_cases("native-2026", True),
+    ),
+    # Vowel + anuswara (e.g. കലാം, ടീം); anuswara behaves as -മ- and suffixes take the
+    # -ഇന- linker. acc/gen native-ratified (worksheet A); dative extrapolated.
+    "vowel_anuswara": NounClass(
+        name="vowel_anuswara",
+        description="Vowel + anuswara nouns (e.g. കലാം, ടീം); -മ- stem with -ഇന- linker.",
+        endings=("ം",),
+        pre="vowel",
+        oblique=StemTransform("ം", "മ"),
+        cases={
+            Case.NOMINATIVE: CaseRule("", False, "native-2026", True),
+            Case.ACCUSATIVE: CaseRule("ിനെ", True, "native-2026", True),
+            Case.GENITIVE: CaseRule("ിന്റെ", True, "native-2026", True),
+            Case.DATIVE: CaseRule("ിന്", True, "native-2026", True),
+            Case.SOCIATIVE: CaseRule("ിനോട്", True, "native-2026", True),
+            Case.LOCATIVE: CaseRule("ിൽ", True, "native-2026", True),
+            Case.VOCATIVE: CaseRule("േ", True, "native-2026", True),
+            Case.ABLATIVE: CaseRule("ിൽനിന്ന്", True, "native-2026", True),
+            Case.ALLATIVE: CaseRule("ിലേക്ക്", True, "native-2026", True),
+            Case.PERLATIVE: CaseRule("ിലൂടെ", True, "native-2026", True),
+        },
+        plural_marker=StemTransform("", ""),
+        plural_cases={},
+    ),
+    # Vowel-final -ി nouns (e.g. കുട്ടി); glide -യ-, dative on root. Singular core +
+    # abl/all/perl native-ratified (worksheet); genitive #14.
+    "i_vowel": NounClass(
+        name="i_vowel",
+        description="Vowel-final nouns ending in -ി (e.g. കുട്ടി 'child'); glide -യ-.",
+        endings=("ി",),
+        oblique=StemTransform("", "യ"),
+        cases={
+            Case.NOMINATIVE: CaseRule("", False, "native-2026", True),
+            Case.ACCUSATIVE: CaseRule("െ", True, "native-2026", True),
+            Case.DATIVE: CaseRule("ക്ക്", False, "native-2026", True),
+            Case.GENITIVE: CaseRule("ുടെ", True, "native-14", True),
+            Case.SOCIATIVE: CaseRule("ോട്", True, "native-2026", True),
+            Case.LOCATIVE: CaseRule("ിൽ", True, "native-2026", True),
+            Case.INSTRUMENTAL: CaseRule("ാൽ", True, "native-2026", True),
+            Case.VOCATIVE: CaseRule("േ", True, "native-2026", True),
+            Case.ABLATIVE: CaseRule("ിൽനിന്ന്", True, "native-2026", True),
+            Case.ALLATIVE: CaseRule("ിലേക്ക്", True, "native-2026", True),
+            Case.PERLATIVE: CaseRule("ിലൂടെ", True, "native-2026", True),
+        },
+        plural_marker=StemTransform("", "കൾ"),
+        plural_cases=_plural_cases("native-2026", True),
+    ),
+    # Vowel-final -ഉ/-ഊ nouns (e.g. പശു, മുത്തു); glide -വ-. gen/vocative native-
+    # ratified (worksheet A); acc/dat/loc extrapolated from the -ഇന- linker pattern.
+    "u_vowel": NounClass(
+        name="u_vowel",
+        description="Vowel-final nouns ending in -ഉ/-ഊ (e.g. പശു 'cow'); glide -വ-.",
+        endings=("ു", "ൂ"),
+        oblique=StemTransform("", "വ"),
+        cases={
+            Case.NOMINATIVE: CaseRule("", False, "native-2026", True),
+            Case.ACCUSATIVE: CaseRule("ിനെ", True, "native-2026", True),
+            Case.DATIVE: CaseRule("ിന്", True, "native-2026", True),
+            Case.GENITIVE: CaseRule("ിന്റെ", True, "native-2026", True),
+            Case.SOCIATIVE: CaseRule("ിനോട്", True, "native-2026", True),
+            Case.LOCATIVE: CaseRule("ിൽ", True, "native-2026", True),
+            Case.INSTRUMENTAL: CaseRule("ിനാൽ", True, "native-2026", True),
+            Case.VOCATIVE: CaseRule("േ", True, "native-2026", True),
+            Case.ABLATIVE: CaseRule("ിൽനിന്ന്", True, "native-2026", True),
+            Case.ALLATIVE: CaseRule("ിലേക്ക്", True, "native-2026", True),
+            Case.PERLATIVE: CaseRule("ിലൂടെ", True, "native-2026", True),
+        },
+        plural_marker=StemTransform("", "ക്കൾ"),  # പശു -> പശുക്കൾ (marker native-given)
+        plural_cases=_plural_cases("smc-morph", False),
+    ),
+    # -ട് final nouns (e.g. വീട്, കാട്); geminate ട്->ട്ട for the spatial cases, plain
+    # stem (-ഇന- linker) for gen/dat. Worksheet A native-ratified; perlative extrapolated.
+    "ṭ_geminate": NounClass(
+        name="ṭ_geminate",
+        description="-ട് final nouns (e.g. വീട് 'house'); geminate ട്->ട്ട for spatial cases.",
+        endings=("ട്",),
+        oblique=StemTransform("്", ""),  # plain oblique for gen/dat/acc/soc/voc: വീട്->വീട
+        cases={
+            Case.NOMINATIVE: CaseRule("", False, "native-2026", True),
+            Case.ACCUSATIVE: CaseRule("ിനെ", True, "native-2026", True),
+            Case.DATIVE: CaseRule("ിന്", True, "native-2026", True),
+            Case.GENITIVE: CaseRule("ിന്റെ", True, "native-2026", True),
+            Case.SOCIATIVE: CaseRule("ിനോട്", True, "native-2026", True),
+            Case.VOCATIVE: CaseRule("േ", True, "native-2026", True),
+            Case.LOCATIVE: CaseRule("ിൽ", True, "native-2026", True, oblique=_GEMINATE_T),
+            Case.ALLATIVE: CaseRule("ിലേക്ക്", True, "native-2026", True, oblique=_GEMINATE_T),
+            Case.ABLATIVE: CaseRule("ിൽനിന്ന്", True, "native-2026", True, oblique=_GEMINATE_T),
+            Case.PERLATIVE: CaseRule("ിലൂടെ", True, "native-2026", True, oblique=_GEMINATE_T),
+        },
+        plural_marker=StemTransform("", ""),
+        plural_cases={},
+    ),
+}

mlinflect-0.0.1/src/mlinflect/types.py

@@ -0,0 +1,79 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Jayashankar R
+"""Typed feature inventory and result types for Malayalam noun synthesis.
+
+Feature values match the mlmorph tagset (gitlab.com/smc/mlmorph) for interop, with
+two features mlmorph leaves lexical: ``Animacy`` (drives differential object marking
+and plural choice) and ``Register`` (synthetic vs analytic forms).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import List, Optional
+
+
+class Case(str, Enum):
+    NOMINATIVE = "nominative"
+    ACCUSATIVE = "accusative"
+    DATIVE = "dative"
+    GENITIVE = "genitive"
+    SOCIATIVE = "sociative"
+    LOCATIVE = "locative"
+    INSTRUMENTAL = "instrumental"
+    VOCATIVE = "vocative"
+    ABLATIVE = "ablative"
+    ALLATIVE = "allative"
+    PERLATIVE = "perlative"
+
+
+class Number(str, Enum):
+    SINGULAR = "singular"
+    PLURAL = "plural"
+
+
+class Gender(str, Enum):
+    MASCULINE = "masculine"
+    FEMININE = "feminine"
+    NEUTRAL = "neutral"
+
+
+class Animacy(str, Enum):
+    """Lexical animacy/humanness. Governs accusative marking (DOM) and plural choice."""
+
+    HUMAN = "human"
+    ANIMATE = "animate"  # animate, non-human (e.g. കിളി 'bird')
+    INANIMATE = "inanimate"
+
+
+class Register(str, Enum):
+    FORMAL = "formal"        # synthetic forms (e.g. instrumental മരത്താൽ)
+    COLLOQUIAL = "colloquial"  # analytic forms (e.g. മരം കൊണ്ട്)
+
+
+@dataclass(frozen=True)
+class NounFeatures:
+    case: Case
+    number: Number = Number.SINGULAR
+    animacy: Optional[Animacy] = None
+    register: Register = Register.FORMAL
+    gender: Optional[Gender] = None
+
+
+@dataclass(frozen=True)
+class SynthResult:
+    """One synthesized inflected form.
+
+    ``provenance`` is the citation key of the rule that produced it (see REFERENCES.md);
+    ``verified`` is true only for native-ratified forms; ``analytic`` is true for
+    multi-word forms (e.g. the colloquial instrumental മരം കൊണ്ട്).
+    """
+
+    surface: str
+    root: str
+    features: NounFeatures
+    morphemes: List[str]
+    stem_class: str
+    provenance: str
+    verified: bool
+    analytic: bool = False

mlinflect-0.0.1/tests/test_nouns.py

@@ -0,0 +1,195 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2026 Jayashankar R
+"""Tests for mlsynth noun synthesis.
+
+Expected surface forms are typed as independent literals (the forms attested in the
+sources / native worksheet), and the engine constructs them from root + rules, so a
+passing test confirms the rule encoding reproduces the attested paradigm rather than
+being a tautology.
+"""
+import pytest
+
+from mlsynth import (
+    Animacy,
+    Case,
+    Number,
+    Register,
+    UnsupportedRoot,
+    list_supported_classes,
+    synthesize_noun,
+)
+
+# മരം 'tree', consonant + anuswara class.
+AM = "മരം"
+AM_SG = {
+    Case.NOMINATIVE: "മരം", Case.ACCUSATIVE: "മരത്തെ", Case.DATIVE: "മരത്തിന്",
+    Case.GENITIVE: "മരത്തിന്റെ", Case.SOCIATIVE: "മരത്തോട്", Case.LOCATIVE: "മരത്തിൽ",
+    Case.INSTRUMENTAL: "മരത്താൽ", Case.VOCATIVE: "മരമേ", Case.ABLATIVE: "മരത്തിൽനിന്ന്",
+    Case.ALLATIVE: "മരത്തിലേക്ക്", Case.PERLATIVE: "മരത്തിലൂടെ",
+}
+AM_PL = {
+    Case.NOMINATIVE: "മരങ്ങൾ", Case.ACCUSATIVE: "മരങ്ങളെ", Case.DATIVE: "മരങ്ങൾക്ക്",
+    Case.GENITIVE: "മരങ്ങളുടെ", Case.SOCIATIVE: "മരങ്ങളോട്", Case.LOCATIVE: "മരങ്ങളിൽ",
+    Case.INSTRUMENTAL: "മരങ്ങളാൽ", Case.VOCATIVE: "മരങ്ങളേ",
+}
+
+# കുട്ടി 'child', vowel-final -ി class.
+KUTTI = "കുട്ടി"
+KUTTI_SG = {
+    Case.NOMINATIVE: "കുട്ടി", Case.ACCUSATIVE: "കുട്ടിയെ", Case.DATIVE: "കുട്ടിക്ക്",
+    Case.GENITIVE: "കുട്ടിയുടെ", Case.SOCIATIVE: "കുട്ടിയോട്", Case.LOCATIVE: "കുട്ടിയിൽ",
+    Case.INSTRUMENTAL: "കുട്ടിയാൽ", Case.VOCATIVE: "കുട്ടിയേ",
+}
+KUTTI_PL = {
+    Case.NOMINATIVE: "കുട്ടികൾ", Case.ACCUSATIVE: "കുട്ടികളെ", Case.DATIVE: "കുട്ടികൾക്ക്",
+    Case.GENITIVE: "കുട്ടികളുടെ", Case.VOCATIVE: "കുട്ടികളേ",
+}
+
+
+@pytest.mark.parametrize("case,expected", list(AM_SG.items()))
+def test_am_singular(case, expected):
+    assert synthesize_noun(AM, case).surface == expected
+
+
+@pytest.mark.parametrize("case,expected", list(AM_PL.items()))
+def test_am_plural(case, expected):
+    assert synthesize_noun(AM, case, number=Number.PLURAL).surface == expected
+
+
+@pytest.mark.parametrize("case,expected", list(KUTTI_SG.items()))
+def test_i_vowel_singular(case, expected):
+    assert synthesize_noun(KUTTI, case).surface == expected
+
+
+@pytest.mark.parametrize("case,expected", list(KUTTI_PL.items()))
+def test_i_vowel_plural(case, expected):
+    assert synthesize_noun(KUTTI, case, number=Number.PLURAL).surface == expected
+
+
+# --- new classes ---
+
+@pytest.mark.parametrize("root,case,expected", [
+    ("കലാം", Case.ACCUSATIVE, "കലാമിനെ"),
+    ("കലാം", Case.GENITIVE, "കലാമിന്റെ"),
+    ("ടീം", Case.GENITIVE, "ടീമിന്റെ"),
+    ("ഓം", Case.ACCUSATIVE, "ഓമിനെ"),      # independent vowel + anuswara
+    ("ക്രീം", Case.ACCUSATIVE, "ക്രീമിനെ"),
+    ("കലാം", Case.SOCIATIVE, "കലാമിനോട്"),
+    ("കലാം", Case.VOCATIVE, "കലാമേ"),
+    ("കലാം", Case.ABLATIVE, "കലാമിൽനിന്ന്"),
+])
+def test_vowel_anuswara(root, case, expected):
+    assert synthesize_noun(root, case).surface == expected
+
+
+@pytest.mark.parametrize("root,case,expected", [
+    ("പശു", Case.GENITIVE, "പശുവിന്റെ"),
+    ("പശു", Case.VOCATIVE, "പശുവേ"),
+    ("മുത്തു", Case.VOCATIVE, "മുത്തുവേ"),
+    ("പശു", Case.DATIVE, "പശുവിന്"),
+    ("പശു", Case.ACCUSATIVE, "പശുവിനെ"),
+    ("പശു", Case.SOCIATIVE, "പശുവിനോട്"),
+    ("പശു", Case.INSTRUMENTAL, "പശുവിനാൽ"),
+])
+def test_u_vowel(root, case, expected):
+    assert synthesize_noun(root, case).surface == expected
+
+
+def test_u_vowel_plural_marker():
+    assert synthesize_noun("പശു", Case.NOMINATIVE, number=Number.PLURAL).surface == "പശുക്കൾ"
+
+
+@pytest.mark.parametrize("root,case,expected", [
+    ("വീട്", Case.GENITIVE, "വീടിന്റെ"),       # plain stem
+    ("വീട്", Case.DATIVE, "വീടിന്"),
+    ("വീട്", Case.ACCUSATIVE, "വീടിനെ"),
+    ("വീട്", Case.VOCATIVE, "വീടേ"),
+    ("വീട്", Case.LOCATIVE, "വീട്ടിൽ"),         # geminated stem
+    ("വീട്", Case.ALLATIVE, "വീട്ടിലേക്ക്"),
+    ("വീട്", Case.ABLATIVE, "വീട്ടിൽനിന്ന്"),
+    ("വീട്", Case.PERLATIVE, "വീട്ടിലൂടെ"),
+    ("കാട്", Case.GENITIVE, "കാടിന്റെ"),
+    ("കാട്", Case.LOCATIVE, "കാട്ടിൽ"),
+])
+def test_t_geminate(root, case, expected):
+    assert synthesize_noun(root, case).surface == expected
+
+
+def test_vocative():
+    assert synthesize_noun("മരം", Case.VOCATIVE).surface == "മരമേ"
+    assert synthesize_noun("മരം", Case.VOCATIVE, number=Number.PLURAL).surface == "മരങ്ങളേ"
+    assert synthesize_noun("കുട്ടി", Case.VOCATIVE, number=Number.PLURAL).surface == "കുട്ടികളേ"
+
+
+# --- differential object marking + register ---
+
+def test_inanimate_accusative_defaults_bare():
+    assert synthesize_noun(AM, Case.ACCUSATIVE, animacy=Animacy.INANIMATE).surface == "മരം"
+
+
+def test_inanimate_accusative_marked_on_request():
+    assert synthesize_noun(AM, Case.ACCUSATIVE, animacy=Animacy.INANIMATE, marked=True).surface == "മരത്തെ"
+
+
+def test_animate_accusative_is_overt():
+    assert synthesize_noun(KUTTI, Case.ACCUSATIVE, animacy=Animacy.HUMAN).surface == "കുട്ടിയെ"
+
+
+def test_colloquial_instrumental_is_analytic():
+    r = synthesize_noun(AM, Case.INSTRUMENTAL, register=Register.COLLOQUIAL)
+    assert r.surface == "മരം കൊണ്ട്" and r.analytic is True
+
+
+def test_dom_and_register_inherit_nominative_flags():
+    # The DOM/register forms inherit verified/provenance from the nominative they are
+    # built on, so they never over-claim relative to it.
+    nom = synthesize_noun(KUTTI, Case.NOMINATIVE)
+    bare = synthesize_noun(KUTTI, Case.ACCUSATIVE, animacy=Animacy.INANIMATE)
+    assert (bare.surface, bare.verified, bare.provenance) == (nom.surface, nom.verified, nom.provenance)
+
+
+# --- verified / provenance discipline ---
+
+def test_native_ratified_forms_are_verified():
+    assert synthesize_noun(AM, Case.ABLATIVE).verified is True            # worksheet C
+    assert synthesize_noun(KUTTI, Case.GENITIVE).provenance == "native-14"
+    assert synthesize_noun("വീട്", Case.LOCATIVE).verified is True
+
+
+def test_extrapolated_forms_are_unverified():
+    # u_vowel plural: only the -ക്കൾ marker is native-given; the oblique paradigm is extrapolated.
+    r = synthesize_noun("പശു", Case.GENITIVE, number=Number.PLURAL)
+    assert r.surface == "പശുക്കളുടെ" and r.verified is False
+
+
+def test_morphemes_join_to_surface():
+    r = synthesize_noun(AM, Case.LOCATIVE)
+    assert "".join(r.morphemes) == r.surface
+
+
+# --- soundness: raise, never silently wrong ---
+
+@pytest.mark.parametrize("root", ["അമ്മ", "പുഴ", "അവൻ", "നായർ", "സ്ത്രീ", "ABC", "123", "ി", ""])
+def test_unsupported_roots_raise(root):
+    with pytest.raises(UnsupportedRoot):
+        synthesize_noun(root, Case.GENITIVE)
+
+
+def test_explicit_mismatched_class_raises():
+    with pytest.raises(UnsupportedRoot):
+        synthesize_noun(AM, Case.ACCUSATIVE, stem_class="i_vowel")
+
+
+def test_unencoded_case_raises():
+    with pytest.raises(NotImplementedError):
+        synthesize_noun("കലാം", Case.INSTRUMENTAL)    # vowel_anuswara has no instrumental yet
+
+
+def test_unencoded_plural_raises():
+    with pytest.raises(NotImplementedError):
+        synthesize_noun("കലാം", Case.GENITIVE, number=Number.PLURAL)  # no plural encoded
+
+
+def test_supported_classes_listed():
+    cls = list_supported_classes()
+    assert {"am_neuter", "i_vowel", "vowel_anuswara", "u_vowel", "ṭ_geminate"} <= set(cls)