india-address-parser 0.1.0__tar.gz

india_address_parser-0.1.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 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.

india_address_parser-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: india-address-parser
+Version: 0.1.0
+Summary: Parse messy Indian addresses into structured JSON with a small local model (GGUF).
+License-Expression: Apache-2.0
+Project-URL: Model, https://huggingface.co/abr-6024/indian-address-parser-1.5B
+Project-URL: GGUF, https://huggingface.co/abr-6024/indian-address-parser-1.5B-GGUF
+Project-URL: Dataset, https://huggingface.co/datasets/abr-6024/indian-address-parsing-synthetic
+Keywords: address,india,parser,gguf,llama.cpp,nlp
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: llama-cpp-python>=0.3.0
+Requires-Dist: huggingface_hub>=0.23
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# india-address-parser
+
+Parse messy Indian addresses into structured fields with a small local model (1.5B, runs on CPU, no API key).
+
+```python
+from india_address_parser import parse
+
+parse("D.No 14/2, Gandhi Road, Pollachi, Coimbatore - 642001")
+# {'flat': '14/2', 'building': '', 'street': 'Gandhi Road', 'landmark': '', 'area': 'Pollachi',
+#  'city': 'Coimbatore', 'state': 'Tamil Nadu', 'pincode': '642001', 'phone': ''}
+```
+
+The model is [abr-6024/indian-address-parser-1.5B](https://huggingface.co/abr-6024/indian-address-parser-1.5B),
+a fine-tune of Qwen2.5-1.5B-Instruct, run through [llama.cpp](https://github.com/ggml-org/llama.cpp) as a
+[GGUF file](https://huggingface.co/abr-6024/indian-address-parser-1.5B-GGUF).
+
+## Install
+
+```
+pip install india-address-parser
+```
+
+The first call downloads the model (Q4_K_M, about 1 GB) from Hugging Face and caches it. After that it runs offline.
+`llama-cpp-python` is installed as a dependency. If pip has to compile it and fails, install a prebuilt CPU wheel first:
+
+```
+pip install llama-cpp-python --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu
+```
+
+## Use
+
+```python
+from india_address_parser import AddressParser
+
+p = AddressParser()                       # loads the model once
+p.parse("Flat 3B, Sri Murugan Apartments, Peelamedu, Coimbatore 641004, 9442012345")
+p.parse_many(["12, Mettu Street, Karaikudi, Sivaganga District 630001", "..."])
+
+AddressParser(model_path="my.gguf")       # use a local GGUF file instead of downloading
+```
+
+Command line:
+
+```
+india-address-parser "No 21, East Car Street, Srirangam, Tiruchirappalli 620006"
+cat addresses.txt | india-address-parser          # one address per line, one JSON object per line out
+```
+
+Every result has exactly these keys: `flat, building, street, landmark, area, city, state, pincode, phone`.
+Anything not written in the address is an empty string.
+
+## Conventions
+
+- `city` is the **district** name (or the metro name for big cities), not necessarily the town written in the address.
+- `area` is the locality, village or post-office name. `flat` is the door or house number only.
+- The model does not guess a city that is not written. It fills the state when the city or pincode implies it.
+
+## Accuracy and limits
+
+The default file (Q4_K_M) scored 94.0% full-record exact match on 200 random synthetic test addresses, 29 of 30 on a
+hand-written Tamil Nadu set and 28 of 36 on a hand-written mixed-India set. The original unquantized model scored
+94.4% on all 800 synthetic test addresses. The hand-written sets were written by the model's author, so they are not
+independent benchmarks. Details: [GGUF model card](https://huggingface.co/abr-6024/indian-address-parser-1.5B-GGUF).
+
+- The model was trained on synthetic address text over real India Post geography. **Accuracy on real customer
+  addresses has not been measured** and is likely lower. Test it on your own data before relying on it.
+- Bare-number addresses such as `15 Gandhi Salai, Tirupur` can lose the house number.
+- Pincodes are extracted, not validated against the locality. English / Latin script only.
+- `parse` raises `ValueError` if the model does not return a JSON object. Handle that in production code.
+
+## Credits and license
+
+Code: Apache-2.0. Base model: Qwen2.5-1.5B-Instruct (Apache-2.0). Training geography: All India Pincode Directory,
+Department of Posts, Government of India (data.gov.in, GODL-India).

india_address_parser-0.1.0/README.md

@@ -0,0 +1,74 @@
+# india-address-parser
+
+Parse messy Indian addresses into structured fields with a small local model (1.5B, runs on CPU, no API key).
+
+```python
+from india_address_parser import parse
+
+parse("D.No 14/2, Gandhi Road, Pollachi, Coimbatore - 642001")
+# {'flat': '14/2', 'building': '', 'street': 'Gandhi Road', 'landmark': '', 'area': 'Pollachi',
+#  'city': 'Coimbatore', 'state': 'Tamil Nadu', 'pincode': '642001', 'phone': ''}
+```
+
+The model is [abr-6024/indian-address-parser-1.5B](https://huggingface.co/abr-6024/indian-address-parser-1.5B),
+a fine-tune of Qwen2.5-1.5B-Instruct, run through [llama.cpp](https://github.com/ggml-org/llama.cpp) as a
+[GGUF file](https://huggingface.co/abr-6024/indian-address-parser-1.5B-GGUF).
+
+## Install
+
+```
+pip install india-address-parser
+```
+
+The first call downloads the model (Q4_K_M, about 1 GB) from Hugging Face and caches it. After that it runs offline.
+`llama-cpp-python` is installed as a dependency. If pip has to compile it and fails, install a prebuilt CPU wheel first:
+
+```
+pip install llama-cpp-python --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu
+```
+
+## Use
+
+```python
+from india_address_parser import AddressParser
+
+p = AddressParser()                       # loads the model once
+p.parse("Flat 3B, Sri Murugan Apartments, Peelamedu, Coimbatore 641004, 9442012345")
+p.parse_many(["12, Mettu Street, Karaikudi, Sivaganga District 630001", "..."])
+
+AddressParser(model_path="my.gguf")       # use a local GGUF file instead of downloading
+```
+
+Command line:
+
+```
+india-address-parser "No 21, East Car Street, Srirangam, Tiruchirappalli 620006"
+cat addresses.txt | india-address-parser          # one address per line, one JSON object per line out
+```
+
+Every result has exactly these keys: `flat, building, street, landmark, area, city, state, pincode, phone`.
+Anything not written in the address is an empty string.
+
+## Conventions
+
+- `city` is the **district** name (or the metro name for big cities), not necessarily the town written in the address.
+- `area` is the locality, village or post-office name. `flat` is the door or house number only.
+- The model does not guess a city that is not written. It fills the state when the city or pincode implies it.
+
+## Accuracy and limits
+
+The default file (Q4_K_M) scored 94.0% full-record exact match on 200 random synthetic test addresses, 29 of 30 on a
+hand-written Tamil Nadu set and 28 of 36 on a hand-written mixed-India set. The original unquantized model scored
+94.4% on all 800 synthetic test addresses. The hand-written sets were written by the model's author, so they are not
+independent benchmarks. Details: [GGUF model card](https://huggingface.co/abr-6024/indian-address-parser-1.5B-GGUF).
+
+- The model was trained on synthetic address text over real India Post geography. **Accuracy on real customer
+  addresses has not been measured** and is likely lower. Test it on your own data before relying on it.
+- Bare-number addresses such as `15 Gandhi Salai, Tirupur` can lose the house number.
+- Pincodes are extracted, not validated against the locality. English / Latin script only.
+- `parse` raises `ValueError` if the model does not return a JSON object. Handle that in production code.
+
+## Credits and license
+
+Code: Apache-2.0. Base model: Qwen2.5-1.5B-Instruct (Apache-2.0). Training geography: All India Pincode Directory,
+Department of Posts, Government of India (data.gov.in, GODL-India).

india_address_parser-0.1.0/india_address_parser/__init__.py

@@ -0,0 +1,4 @@
+from .parser import DEFAULT_FILE, DEFAULT_REPO, FIELDS, SYSTEM, AddressParser, parse
+
+__version__ = "0.1.0"
+__all__ = ["AddressParser", "parse", "FIELDS", "SYSTEM", "DEFAULT_REPO", "DEFAULT_FILE", "__version__"]

india_address_parser-0.1.0/india_address_parser/cli.py

@@ -0,0 +1,26 @@
+import argparse
+import json
+import sys
+
+from . import __version__
+from .parser import AddressParser
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="india-address-parser",
+                                 description="Parse Indian addresses into JSON with a local model.")
+    ap.add_argument("address", nargs="*", help="address text; if omitted, one address per line is read from stdin")
+    ap.add_argument("--model", help="path to a local .gguf file (default: download Q4_K_M from Hugging Face)")
+    ap.add_argument("--version", action="version", version=__version__)
+    args = ap.parse_args(argv)
+
+    addresses = [" ".join(args.address)] if args.address else [l.strip() for l in sys.stdin if l.strip()]
+    if not addresses:
+        ap.error("no address given")
+    parser = AddressParser(model_path=args.model)
+    for a in addresses:
+        print(json.dumps(parser.parse(a), ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

india_address_parser-0.1.0/india_address_parser/parser.py

@@ -0,0 +1,76 @@
+"""Parse messy Indian addresses into structured fields with a local GGUF model."""
+import json
+from typing import Dict, Iterable, List, Optional
+
+FIELDS = ["flat", "building", "street", "landmark", "area", "city", "state", "pincode", "phone"]
+
+# Must match the system prompt the model was trained with.
+SYSTEM = ("You are an Indian address parser. Convert the address into JSON with exactly these keys: "
+          "flat, building, street, landmark, area, city, state, pincode, phone. "
+          "Use an empty string for anything missing. Output only JSON.")
+
+DEFAULT_REPO = "abr-6024/indian-address-parser-1.5B-GGUF"
+DEFAULT_FILE = "*Q4_K_M.gguf"
+
+
+def _clean(raw: str) -> Dict[str, str]:
+    """Turn the model's text into a dict with exactly the nine expected string fields."""
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"model did not return valid JSON: {raw!r}") from exc
+    if not isinstance(data, dict):
+        raise ValueError(f"model returned JSON that is not an object: {raw!r}")
+    return {k: "" if data.get(k) is None else str(data[k]) for k in FIELDS}
+
+
+class AddressParser:
+    """Loads the model once; call :meth:`parse` as many times as you like.
+
+    By default the Q4_K_M file (about 1 GB) is downloaded from Hugging Face on first use and cached.
+    Pass ``model_path`` to use a local .gguf file instead.
+    """
+
+    def __init__(self, model_path: Optional[str] = None, repo_id: str = DEFAULT_REPO,
+                 filename: str = DEFAULT_FILE, n_ctx: int = 1024, n_threads: Optional[int] = None,
+                 verbose: bool = False):
+        try:
+            from llama_cpp import Llama
+        except ImportError as exc:  # pragma: no cover
+            raise ImportError("llama-cpp-python is required: pip install llama-cpp-python") from exc
+        kwargs = dict(n_ctx=n_ctx, verbose=verbose)
+        if n_threads:
+            kwargs["n_threads"] = n_threads
+        if model_path:
+            self._llm = Llama(model_path=model_path, **kwargs)
+        else:
+            self._llm = Llama.from_pretrained(repo_id=repo_id, filename=filename, **kwargs)
+
+    def parse(self, address: str) -> Dict[str, str]:
+        """Return a dict with keys flat, building, street, landmark, area, city, state, pincode, phone.
+
+        Fields not written in the address are empty strings. ``city`` is the district (or metro) name.
+        Raises ValueError if the model output is not a JSON object.
+        """
+        if not address or not address.strip():
+            raise ValueError("address is empty")
+        out = self._llm.create_chat_completion(
+            messages=[{"role": "system", "content": SYSTEM}, {"role": "user", "content": address.strip()}],
+            temperature=0.0,
+            max_tokens=200,
+        )
+        return _clean(out["choices"][0]["message"]["content"])
+
+    def parse_many(self, addresses: Iterable[str]) -> List[Dict[str, str]]:
+        return [self.parse(a) for a in addresses]
+
+
+_default: Optional[AddressParser] = None
+
+
+def parse(address: str) -> Dict[str, str]:
+    """Parse one address with a shared default model (downloaded and loaded on the first call)."""
+    global _default
+    if _default is None:
+        _default = AddressParser()
+    return _default.parse(address)

india_address_parser-0.1.0/india_address_parser.egg-info/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: india-address-parser
+Version: 0.1.0
+Summary: Parse messy Indian addresses into structured JSON with a small local model (GGUF).
+License-Expression: Apache-2.0
+Project-URL: Model, https://huggingface.co/abr-6024/indian-address-parser-1.5B
+Project-URL: GGUF, https://huggingface.co/abr-6024/indian-address-parser-1.5B-GGUF
+Project-URL: Dataset, https://huggingface.co/datasets/abr-6024/indian-address-parsing-synthetic
+Keywords: address,india,parser,gguf,llama.cpp,nlp
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: llama-cpp-python>=0.3.0
+Requires-Dist: huggingface_hub>=0.23
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# india-address-parser
+
+Parse messy Indian addresses into structured fields with a small local model (1.5B, runs on CPU, no API key).
+
+```python
+from india_address_parser import parse
+
+parse("D.No 14/2, Gandhi Road, Pollachi, Coimbatore - 642001")
+# {'flat': '14/2', 'building': '', 'street': 'Gandhi Road', 'landmark': '', 'area': 'Pollachi',
+#  'city': 'Coimbatore', 'state': 'Tamil Nadu', 'pincode': '642001', 'phone': ''}
+```
+
+The model is [abr-6024/indian-address-parser-1.5B](https://huggingface.co/abr-6024/indian-address-parser-1.5B),
+a fine-tune of Qwen2.5-1.5B-Instruct, run through [llama.cpp](https://github.com/ggml-org/llama.cpp) as a
+[GGUF file](https://huggingface.co/abr-6024/indian-address-parser-1.5B-GGUF).
+
+## Install
+
+```
+pip install india-address-parser
+```
+
+The first call downloads the model (Q4_K_M, about 1 GB) from Hugging Face and caches it. After that it runs offline.
+`llama-cpp-python` is installed as a dependency. If pip has to compile it and fails, install a prebuilt CPU wheel first:
+
+```
+pip install llama-cpp-python --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu
+```
+
+## Use
+
+```python
+from india_address_parser import AddressParser
+
+p = AddressParser()                       # loads the model once
+p.parse("Flat 3B, Sri Murugan Apartments, Peelamedu, Coimbatore 641004, 9442012345")
+p.parse_many(["12, Mettu Street, Karaikudi, Sivaganga District 630001", "..."])
+
+AddressParser(model_path="my.gguf")       # use a local GGUF file instead of downloading
+```
+
+Command line:
+
+```
+india-address-parser "No 21, East Car Street, Srirangam, Tiruchirappalli 620006"
+cat addresses.txt | india-address-parser          # one address per line, one JSON object per line out
+```
+
+Every result has exactly these keys: `flat, building, street, landmark, area, city, state, pincode, phone`.
+Anything not written in the address is an empty string.
+
+## Conventions
+
+- `city` is the **district** name (or the metro name for big cities), not necessarily the town written in the address.
+- `area` is the locality, village or post-office name. `flat` is the door or house number only.
+- The model does not guess a city that is not written. It fills the state when the city or pincode implies it.
+
+## Accuracy and limits
+
+The default file (Q4_K_M) scored 94.0% full-record exact match on 200 random synthetic test addresses, 29 of 30 on a
+hand-written Tamil Nadu set and 28 of 36 on a hand-written mixed-India set. The original unquantized model scored
+94.4% on all 800 synthetic test addresses. The hand-written sets were written by the model's author, so they are not
+independent benchmarks. Details: [GGUF model card](https://huggingface.co/abr-6024/indian-address-parser-1.5B-GGUF).
+
+- The model was trained on synthetic address text over real India Post geography. **Accuracy on real customer
+  addresses has not been measured** and is likely lower. Test it on your own data before relying on it.
+- Bare-number addresses such as `15 Gandhi Salai, Tirupur` can lose the house number.
+- Pincodes are extracted, not validated against the locality. English / Latin script only.
+- `parse` raises `ValueError` if the model does not return a JSON object. Handle that in production code.
+
+## Credits and license
+
+Code: Apache-2.0. Base model: Qwen2.5-1.5B-Instruct (Apache-2.0). Training geography: All India Pincode Directory,
+Department of Posts, Government of India (data.gov.in, GODL-India).

india_address_parser-0.1.0/india_address_parser.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+india_address_parser/__init__.py
+india_address_parser/cli.py
+india_address_parser/parser.py
+india_address_parser.egg-info/PKG-INFO
+india_address_parser.egg-info/SOURCES.txt
+india_address_parser.egg-info/dependency_links.txt
+india_address_parser.egg-info/entry_points.txt
+india_address_parser.egg-info/requires.txt
+india_address_parser.egg-info/top_level.txt
+tests/test_parser.py

india_address_parser-0.1.0/india_address_parser.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

india_address_parser-0.1.0/india_address_parser.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+india-address-parser = india_address_parser.cli:main

india_address_parser-0.1.0/india_address_parser.egg-info/requires.txt

@@ -0,0 +1,5 @@
+llama-cpp-python>=0.3.0
+huggingface_hub>=0.23
+
+[test]
+pytest

india_address_parser-0.1.0/india_address_parser.egg-info/top_level.txt

@@ -0,0 +1 @@
+india_address_parser

india_address_parser-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "india-address-parser"
+version = "0.1.0"
+description = "Parse messy Indian addresses into structured JSON with a small local model (GGUF)."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+keywords = ["address", "india", "parser", "gguf", "llama.cpp", "nlp"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Topic :: Text Processing :: Linguistic",
+]
+dependencies = ["llama-cpp-python>=0.3.0", "huggingface_hub>=0.23"]
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+[project.urls]
+Model = "https://huggingface.co/abr-6024/indian-address-parser-1.5B"
+GGUF = "https://huggingface.co/abr-6024/indian-address-parser-1.5B-GGUF"
+Dataset = "https://huggingface.co/datasets/abr-6024/indian-address-parsing-synthetic"
+
+[project.scripts]
+india-address-parser = "india_address_parser.cli:main"
+
+[tool.setuptools]
+packages = ["india_address_parser"]

india_address_parser-0.1.0/setup.cfg

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

india_address_parser-0.1.0/tests/test_parser.py

@@ -0,0 +1,69 @@
+import json
+import sys
+import types
+
+import pytest
+
+
+class FakeLlama:
+    reply = json.dumps({"flat": "14/2", "street": "Gandhi Road", "area": "Pollachi", "city": "Coimbatore",
+                        "state": "Tamil Nadu", "pincode": "642001", "extra": "dropped", "phone": None})
+    last_kwargs = None
+
+    def __init__(self, **kwargs):
+        FakeLlama.last_kwargs = kwargs
+
+    @classmethod
+    def from_pretrained(cls, repo_id, filename, **kwargs):
+        inst = cls()
+        cls.last_kwargs = {"repo_id": repo_id, "filename": filename, **kwargs}
+        return inst
+
+    def create_chat_completion(self, messages, temperature, max_tokens):
+        FakeLlama.messages = messages
+        return {"choices": [{"message": {"content": FakeLlama.reply}}]}
+
+
+@pytest.fixture(autouse=True)
+def fake_llama(monkeypatch):
+    mod = types.ModuleType("llama_cpp")
+    mod.Llama = FakeLlama
+    monkeypatch.setitem(sys.modules, "llama_cpp", mod)
+
+
+def test_parse_returns_exactly_nine_string_fields():
+    from india_address_parser import FIELDS, AddressParser
+    out = AddressParser(model_path="x.gguf").parse("D.No 14/2, Gandhi Road, Pollachi, Coimbatore - 642001")
+    assert list(out) == FIELDS
+    assert out["flat"] == "14/2" and out["city"] == "Coimbatore" and out["phone"] == "" and out["building"] == ""
+    assert "extra" not in out
+
+
+def test_uses_training_system_prompt():
+    from india_address_parser import SYSTEM, AddressParser
+    AddressParser(model_path="x.gguf").parse("  anything  ")
+    assert FakeLlama.messages[0] == {"role": "system", "content": SYSTEM}
+    assert FakeLlama.messages[1]["content"] == "anything"
+
+
+def test_default_downloads_q4_k_m_from_hub():
+    from india_address_parser import AddressParser
+    AddressParser()
+    assert FakeLlama.last_kwargs["repo_id"] == "abr-6024/indian-address-parser-1.5B-GGUF"
+    assert FakeLlama.last_kwargs["filename"] == "*Q4_K_M.gguf"
+
+
+def test_invalid_model_output_raises():
+    from india_address_parser import AddressParser
+    FakeLlama.reply = "not json"
+    with pytest.raises(ValueError):
+        AddressParser(model_path="x.gguf").parse("addr")
+    FakeLlama.reply = "[1, 2]"
+    with pytest.raises(ValueError):
+        AddressParser(model_path="x.gguf").parse("addr")
+
+
+def test_empty_address_raises():
+    from india_address_parser import AddressParser
+    with pytest.raises(ValueError):
+        AddressParser(model_path="x.gguf").parse("   ")