django-naija 0.1.0__tar.gz

django_naija-0.1.0/.gitignore

@@ -0,0 +1,42 @@
+# Secrets — never commit
+.env
+.env.*
+!.env.example
+.dev.vars
+*.pem
+
+# Python
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+dist/
+/build/
+packages/*/build/
+
+# Node
+node_modules/
+.npm/
+*.tsbuildinfo
+.wrangler/
+.astro/
+
+# Go
+go/coverage.out
+
+# Local scratch
+.cache/
+raw/
+*.log
+.DS_Store
+Thumbs.db
+
+# Local databases (Django example project)
+*.sqlite3
+
+# Local editor/agent settings
+.claude/

django_naija-0.1.0/LICENSE

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

django_naija-0.1.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: django-naija
+Version: 0.1.0
+Summary: Django and DRF fields for Nigerian phone numbers, NUBAN, plate numbers, states and LGAs.
+Project-URL: Homepage, https://github.com/asgatcreation/naija-data/tree/main/packages/django
+Project-URL: Source, https://github.com/asgatcreation/naija-data
+Project-URL: Issues, https://github.com/asgatcreation/naija-data/issues
+Author: Akanji Oluwaseun Gabriel
+License-Expression: MIT
+License-File: LICENSE
+Keywords: django,drf,lga,nigeria,nuban,phone,states,validators
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: django>=5.2
+Requires-Dist: naija-data<2,>=0.1.0
+Provides-Extra: rest
+Requires-Dist: djangorestframework>=3.15; extra == 'rest'
+Provides-Extra: test
+Requires-Dist: djangorestframework>=3.15; extra == 'test'
+Requires-Dist: pytest-django==4.14.0; extra == 'test'
+Requires-Dist: pytest==8.4.2; extra == 'test'
+Description-Content-Type: text/markdown
+
+# django-naija
+
+Django and Django REST framework fields for Nigerian data, built on
+[naija-data](https://github.com/asgatcreation/naija-data): phone numbers (strict NCC validation),
+NUBAN account numbers (CBN check digit), vehicle plate numbers, states and LGAs.
+
+Website and playground: https://naija-data.asgatcreation.workers.dev · REST API: https://naija-data-api.asgatcreation.workers.dev/v1
+
+```bash
+pip install django-naija            # Django fields, forms and validators
+pip install "django-naija[rest]"    # plus Django REST framework fields
+```
+
+Requires Python 3.10+ and Django 5.2+.
+
+## Models
+
+```python
+from django.db import models
+from django_naija.fields import LGAField, NigerianPhoneField, NUBANField, PlateNumberField, StateField
+
+class Customer(models.Model):
+    phone = NigerianPhoneField(types=["mobile"])   # stored as "+2348031234567"
+    state = StateField()                           # stored as "LA", 37 choices
+    lga = LGAField()                               # stored as "NG025011", 774 choices grouped by state
+    plate = PlateNumberField(blank=True)           # stored as "KJA123AB"
+    account_number = NUBANField(blank=True)        # stored as "0123456789"
+```
+
+Choices are loaded lazily (Django's callable choices), so migrations stay small.
+
+## Forms
+
+```python
+from django import forms
+from django_naija import forms as ngforms
+
+class PayoutForm(ngforms.StateLGAFormMixin, ngforms.NUBANFormMixin, forms.Form):
+    phone = ngforms.NigerianPhoneField(types=["mobile"])
+    state = ngforms.StateField()
+    lga = ngforms.LGAField()            # limited to the chosen state; must belong to it
+    bank = ngforms.BankField()          # banks with a CBN code
+    account_number = ngforms.NUBANField()  # checked against the chosen bank
+```
+
+For a dependent state → LGA menu, `django_naija.choices.lga_choices("LA")` returns the LGAs of one
+state; the example project serves it as JSON at `/lgas/?state=Lagos`.
+
+## Django REST framework
+
+```python
+from rest_framework import serializers
+from django_naija import rest_framework as ngdrf
+
+class PayoutSerializer(serializers.Serializer):
+    phone = ngdrf.NigerianPhoneField(types=["mobile"])
+    state = ngdrf.StateField()          # also accepts "Lagos", "Abuja", "FCT"
+    lga = ngdrf.LGAField()              # also accepts INEC codes and unambiguous names
+    bank = ngdrf.BankField()            # also accepts "058" or "GTB"
+    account_number = ngdrf.NUBANField()
+
+    class Meta:
+        validators = [ngdrf.LGAInStateValidator(), ngdrf.NUBANBankValidator()]
+```
+
+## Error messages
+
+Every failure has a clear, translatable message and a machine-readable code, e.g.
+`reserved` → "This number range is reserved and not in service.",
+`check_digit` → "This account number is not valid for the selected bank.".
+See `django_naija/messages.py`.
+
+## Example project
+
+`example/` is a small Django project using every field (model, form, DRF API, dependent LGA
+endpoint). The tests in `tests/` run against it:
+
+```bash
+pip install -e "packages/python" -e "packages/django[test]"
+cd packages/django && python -m pytest
+```
+
+Plate numbers: only the format is checked. FRSC does not publish its list of LGA plate codes, so
+plates are not mapped to LGAs yet.
+
+Licence: MIT. Data from naija-data: CC BY 4.0, Akanji Oluwaseun Gabriel.

django_naija-0.1.0/README.md

@@ -0,0 +1,86 @@
+# django-naija
+
+Django and Django REST framework fields for Nigerian data, built on
+[naija-data](https://github.com/asgatcreation/naija-data): phone numbers (strict NCC validation),
+NUBAN account numbers (CBN check digit), vehicle plate numbers, states and LGAs.
+
+Website and playground: https://naija-data.asgatcreation.workers.dev · REST API: https://naija-data-api.asgatcreation.workers.dev/v1
+
+```bash
+pip install django-naija            # Django fields, forms and validators
+pip install "django-naija[rest]"    # plus Django REST framework fields
+```
+
+Requires Python 3.10+ and Django 5.2+.
+
+## Models
+
+```python
+from django.db import models
+from django_naija.fields import LGAField, NigerianPhoneField, NUBANField, PlateNumberField, StateField
+
+class Customer(models.Model):
+    phone = NigerianPhoneField(types=["mobile"])   # stored as "+2348031234567"
+    state = StateField()                           # stored as "LA", 37 choices
+    lga = LGAField()                               # stored as "NG025011", 774 choices grouped by state
+    plate = PlateNumberField(blank=True)           # stored as "KJA123AB"
+    account_number = NUBANField(blank=True)        # stored as "0123456789"
+```
+
+Choices are loaded lazily (Django's callable choices), so migrations stay small.
+
+## Forms
+
+```python
+from django import forms
+from django_naija import forms as ngforms
+
+class PayoutForm(ngforms.StateLGAFormMixin, ngforms.NUBANFormMixin, forms.Form):
+    phone = ngforms.NigerianPhoneField(types=["mobile"])
+    state = ngforms.StateField()
+    lga = ngforms.LGAField()            # limited to the chosen state; must belong to it
+    bank = ngforms.BankField()          # banks with a CBN code
+    account_number = ngforms.NUBANField()  # checked against the chosen bank
+```
+
+For a dependent state → LGA menu, `django_naija.choices.lga_choices("LA")` returns the LGAs of one
+state; the example project serves it as JSON at `/lgas/?state=Lagos`.
+
+## Django REST framework
+
+```python
+from rest_framework import serializers
+from django_naija import rest_framework as ngdrf
+
+class PayoutSerializer(serializers.Serializer):
+    phone = ngdrf.NigerianPhoneField(types=["mobile"])
+    state = ngdrf.StateField()          # also accepts "Lagos", "Abuja", "FCT"
+    lga = ngdrf.LGAField()              # also accepts INEC codes and unambiguous names
+    bank = ngdrf.BankField()            # also accepts "058" or "GTB"
+    account_number = ngdrf.NUBANField()
+
+    class Meta:
+        validators = [ngdrf.LGAInStateValidator(), ngdrf.NUBANBankValidator()]
+```
+
+## Error messages
+
+Every failure has a clear, translatable message and a machine-readable code, e.g.
+`reserved` → "This number range is reserved and not in service.",
+`check_digit` → "This account number is not valid for the selected bank.".
+See `django_naija/messages.py`.
+
+## Example project
+
+`example/` is a small Django project using every field (model, form, DRF API, dependent LGA
+endpoint). The tests in `tests/` run against it:
+
+```bash
+pip install -e "packages/python" -e "packages/django[test]"
+cd packages/django && python -m pytest
+```
+
+Plate numbers: only the format is checked. FRSC does not publish its list of LGA plate codes, so
+plates are not mapped to LGAs yet.
+
+Licence: MIT. Data from naija-data: CC BY 4.0, Akanji Oluwaseun Gabriel.

django_naija-0.1.0/example/example_site/settings.py

@@ -0,0 +1,24 @@
+"""Minimal settings for the django-naija example project (development only)."""
+
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+SECRET_KEY = "example-only-not-secret"  # noqa: S105 - example project, never deployed
+DEBUG = True
+ALLOWED_HOSTS = ["localhost", "127.0.0.1", "testserver"]
+
+INSTALLED_APPS = [
+    "django.contrib.contenttypes",
+    "django.contrib.auth",
+    "rest_framework",
+    "shop",
+]
+
+MIDDLEWARE = ["django.middleware.common.CommonMiddleware"]
+ROOT_URLCONF = "example_site.urls"
+DATABASES = {"default": {"ENGINE": "django.db.backends.sqlite3", "NAME": BASE_DIR / "db.sqlite3"}}
+TEMPLATES = [{"BACKEND": "django.template.backends.django.DjangoTemplates", "DIRS": [], "APP_DIRS": True}]
+DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"
+USE_TZ = True
+REST_FRAMEWORK = {"UNAUTHENTICATED_USER": None}

django_naija-0.1.0/example/example_site/urls.py

@@ -0,0 +1,9 @@
+from django.urls import path
+
+from shop import views
+
+urlpatterns = [
+    path("signup/", views.signup, name="signup"),
+    path("lgas/", views.lgas_for_state, name="lgas"),  # for a dependent state -> LGA <select>
+    path("api/customers/", views.CustomerCreate.as_view(), name="customer-create"),
+]

django_naija-0.1.0/example/manage.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+import os
+import sys
+
+if __name__ == "__main__":
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "example_site.settings")
+    from django.core.management import execute_from_command_line
+
+    execute_from_command_line(sys.argv)

django_naija-0.1.0/example/shop/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class ShopConfig(AppConfig):
+    name = "shop"

django_naija-0.1.0/example/shop/forms.py

@@ -0,0 +1,13 @@
+from django import forms
+
+from django_naija import forms as ngforms
+
+from .models import Customer
+
+
+class CustomerForm(ngforms.StateLGAFormMixin, ngforms.NUBANFormMixin, forms.ModelForm):
+    bank = ngforms.BankField(required=False)
+
+    class Meta:
+        model = Customer
+        fields = ["name", "phone", "state", "lga", "plate", "bank", "account_number"]

django_naija-0.1.0/example/shop/migrations/0001_initial.py

@@ -0,0 +1,28 @@
+# Generated by Django 5.2.18 on 2026-10-15 16:52
+
+import django_naija.fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Customer',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=100)),
+                ('phone', django_naija.fields.NigerianPhoneField(types=['mobile'])),
+                ('state', django_naija.fields.StateField()),
+                ('lga', django_naija.fields.LGAField()),
+                ('plate', django_naija.fields.PlateNumberField(blank=True)),
+                ('bank', models.CharField(blank=True, max_length=60)),
+                ('account_number', django_naija.fields.NUBANField(blank=True)),
+            ],
+        ),
+    ]

django_naija-0.1.0/example/shop/models.py

@@ -0,0 +1,16 @@
+from django.db import models
+
+from django_naija.fields import LGAField, NigerianPhoneField, NUBANField, PlateNumberField, StateField
+
+
+class Customer(models.Model):
+    name = models.CharField(max_length=100)
+    phone = NigerianPhoneField(types=["mobile"])  # stored as "+2348031234567"
+    state = StateField()  # stored as "LA"
+    lga = LGAField()  # stored as "NG025011"
+    plate = PlateNumberField(blank=True)  # stored as "KJA123AB"
+    bank = models.CharField(max_length=60, blank=True)  # naija-data bank id, e.g. "gtbank"
+    account_number = NUBANField(blank=True)  # stored as "0123456789"
+
+    def __str__(self) -> str:
+        return self.name

django_naija-0.1.0/example/shop/serializers.py

@@ -0,0 +1,19 @@
+from rest_framework import serializers
+
+from django_naija import rest_framework as ngdrf
+
+from .models import Customer
+
+
+class CustomerSerializer(serializers.ModelSerializer):
+    phone = ngdrf.NigerianPhoneField(types=["mobile"])
+    state = ngdrf.StateField()
+    lga = ngdrf.LGAField()
+    plate = ngdrf.PlateNumberField(required=False, allow_blank=True)
+    bank = ngdrf.BankField(required=False, allow_blank=True)
+    account_number = ngdrf.NUBANField(required=False, allow_blank=True)
+
+    class Meta:
+        model = Customer
+        fields = ["id", "name", "phone", "state", "lga", "plate", "bank", "account_number"]
+        validators = [ngdrf.LGAInStateValidator(), ngdrf.NUBANBankValidator()]

django_naija-0.1.0/example/shop/views.py

@@ -0,0 +1,30 @@
+from django.http import HttpResponse, JsonResponse
+from rest_framework import generics
+
+import naija_data as ng
+from django_naija.choices import lga_choices
+
+from .forms import CustomerForm
+from .serializers import CustomerSerializer
+
+
+def signup(request):
+    form = CustomerForm(request.POST or None)
+    if request.method == "POST" and form.is_valid():
+        customer = form.save()
+        return HttpResponse(f"Saved {customer.name}", status=201)
+    return HttpResponse(form.as_div(), status=400 if request.method == "POST" else 200)
+
+
+def lgas_for_state(request):
+    """GET /lgas/?state=Lagos -> {"lgas": [["NG025001", "Agege"], ...]} for a dependent <select>."""
+    state = ng.get_state(request.GET.get("state", ""))
+    if state is None:
+        return JsonResponse({"error": "Unknown state"}, status=404)
+    return JsonResponse({"state": state.code, "lgas": lga_choices(state.code)})
+
+
+class CustomerCreate(generics.CreateAPIView):
+    serializer_class = CustomerSerializer
+    authentication_classes: list = []
+    permission_classes: list = []

django_naija-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["hatchling==1.27.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "django-naija"
+version = "0.1.0"
+description = "Django and DRF fields for Nigerian phone numbers, NUBAN, plate numbers, states and LGAs."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Akanji Oluwaseun Gabriel" }]
+keywords = ["django", "nigeria", "phone", "nuban", "lga", "states", "validators", "drf"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Framework :: Django",
+  "Framework :: Django :: 5.2",
+  "Framework :: Django :: 6.0",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+]
+dependencies = ["naija-data>=0.1.0,<2", "Django>=5.2"]
+
+[project.optional-dependencies]
+rest = ["djangorestframework>=3.15"]
+test = ["djangorestframework>=3.15", "pytest==8.4.2", "pytest-django==4.14.0"]
+
+[project.urls]
+Homepage = "https://github.com/asgatcreation/naija-data/tree/main/packages/django"
+Source = "https://github.com/asgatcreation/naija-data"
+Issues = "https://github.com/asgatcreation/naija-data/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/django_naija"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src", "tests", "example", "README.md", "LICENSE"]
+
+[tool.pytest.ini_options]
+DJANGO_SETTINGS_MODULE = "example_site.settings"
+pythonpath = ["example"]
+testpaths = ["tests"]

django_naija-0.1.0/src/django_naija/__init__.py

@@ -0,0 +1,10 @@
+"""django-naija: Django and Django REST framework fields for Nigerian data, built on naija-data.
+
+- django_naija.fields          model fields: NigerianPhoneField, NUBANField, PlateNumberField, StateField, LGAField
+- django_naija.forms           form fields and the StateLGAFormMixin / NUBANFormMixin helpers
+- django_naija.rest_framework  serializer fields and validators (needs djangorestframework)
+- django_naija.validators      reusable validators
+- django_naija.choices         state, LGA, ward and bank choice lists
+"""
+
+__version__ = "0.1.0"

django_naija-0.1.0/src/django_naija/choices.py

@@ -0,0 +1,33 @@
+"""Choice lists for states, LGAs and banks. They are functions, so Django (5.0+) can use them as
+callable choices and migrations stay small."""
+
+from __future__ import annotations
+
+from typing import List, Optional, Sequence, Tuple
+
+import naija_data as ng
+
+
+def state_choices() -> List[Tuple[str, str]]:
+    """[("AB", "Abia"), ..., ("FC", "Federal Capital Territory"), ...] stored as ISO 3166-2 codes."""
+    return [(s.code, s.name) for s in ng.states()]
+
+
+def lga_choices(state: Optional[str] = None):
+    """LGAs as (P-code, name) pairs. With `state`, only that state's LGAs; without it, grouped by
+    state for <optgroup> menus: [("Abia", [("NG001001", "Aba North"), ...]), ...]."""
+    if state:
+        return [(l.code, l.name) for l in ng.lgas(state)]
+    return [(s.name, [(l.code, l.name) for l in ng.lgas(s)]) for s in ng.states()]
+
+
+def ward_choices(lga: str, state: Optional[str] = None) -> List[Tuple[str, str]]:
+    """Wards of an LGA as (INEC code, name) pairs."""
+    return [(w.code, w.name) for w in ng.wards(lga, state)]
+
+
+def bank_choices(types: Optional[Sequence[str]] = None, with_cbn_code_only: bool = False) -> List[Tuple[str, str]]:
+    """Active banks as (id, name) pairs, short names first where available. Use
+    with_cbn_code_only=True for account-number forms, so every choice can be NUBAN-checked."""
+    rows = [b for b in ng.banks() if (types is None or b.type in types) and (b.cbn_code or not with_cbn_code_only)]
+    return sorted(((b.id, b.short_name or b.name) for b in rows), key=lambda c: c[1].lower())

django_naija-0.1.0/src/django_naija/fields.py

@@ -0,0 +1,149 @@
+"""Model fields.
+
+    from django_naija.fields import LGAField, NigerianPhoneField, NUBANField, PlateNumberField, StateField
+
+    class Customer(models.Model):
+        phone = NigerianPhoneField(types=["mobile"])   # stored as "+2348031234567"
+        state = StateField()                           # stored as "LA"
+        lga = LGAField()                               # stored as "NG025011"
+        plate = PlateNumberField(blank=True)           # stored as "KJA123AB"
+        account_number = NUBANField(blank=True)        # stored as "0123456789"
+"""
+
+from __future__ import annotations
+
+from typing import Optional, Sequence
+
+import naija_data as ng
+from django.db import models
+
+from . import choices, forms
+from .validators import NUBANValidator, PhoneValidator, PlateValidator, clean_nuban, validate_lga, validate_state
+
+
+class NigerianPhoneField(models.CharField):
+    """Stores numbers in E.164 form ("+2348031234567"); accepts any common input format."""
+
+    description = "Nigerian phone number"
+
+    def __init__(self, *args, types: Optional[Sequence[str]] = None, **kwargs):
+        self.types = tuple(types) if types else None
+        kwargs.setdefault("max_length", 16)
+        super().__init__(*args, **kwargs)
+        self.validators.append(PhoneValidator(self.types))
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        if self.types:
+            kwargs["types"] = list(self.types)
+        if kwargs.get("max_length") == 16:
+            del kwargs["max_length"]
+        return name, path, args, kwargs
+
+    def to_python(self, value):
+        value = super().to_python(value)
+        return (ng.normalize_phone(value) or value) if value else value
+
+    def get_prep_value(self, value):
+        return self.to_python(super().get_prep_value(value))
+
+    def formfield(self, **kwargs):
+        # Input like "+234 (0) 803 123 4567" is longer than the stored form, so don't reuse max_length.
+        return super().formfield(**{"form_class": forms.NigerianPhoneField, "types": self.types, "max_length": 32, **kwargs})
+
+
+class NUBANField(models.CharField):
+    """Stores a 10-digit account number without spaces."""
+
+    description = "NUBAN account number"
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("max_length", 10)
+        super().__init__(*args, **kwargs)
+        self.validators.append(NUBANValidator())
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        if kwargs.get("max_length") == 10:
+            del kwargs["max_length"]
+        return name, path, args, kwargs
+
+    def to_python(self, value):
+        value = super().to_python(value)
+        return clean_nuban(value) if value else value
+
+    def get_prep_value(self, value):
+        return self.to_python(super().get_prep_value(value))
+
+    def formfield(self, **kwargs):
+        return super().formfield(**{"form_class": forms.NUBANField, "max_length": 13, **kwargs})
+
+
+class PlateNumberField(models.CharField):
+    """Stores plate numbers in compact form ("KJA123AB"); use parse_plate(value).display to show them."""
+
+    description = "Vehicle plate number"
+
+    def __init__(self, *args, formats: Optional[Sequence[str]] = None, **kwargs):
+        self.formats = tuple(formats) if formats else None
+        kwargs.setdefault("max_length", 10)
+        super().__init__(*args, **kwargs)
+        self.validators.append(PlateValidator(self.formats))
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        if self.formats:
+            kwargs["formats"] = list(self.formats)
+        if kwargs.get("max_length") == 10:
+            del kwargs["max_length"]
+        return name, path, args, kwargs
+
+    def to_python(self, value):
+        value = super().to_python(value)
+        parsed = ng.parse_plate(value) if value else None
+        return parsed.compact if parsed else value
+
+    def get_prep_value(self, value):
+        return self.to_python(super().get_prep_value(value))
+
+    def formfield(self, **kwargs):
+        return super().formfield(**{"form_class": forms.PlateNumberField, "formats": self.formats, "max_length": 16,
+                                    **kwargs})
+
+
+class StateField(models.CharField):
+    """Stores a state's ISO 3166-2 code ("LA"), with the 37 states as choices."""
+
+    description = "Nigerian state"
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("max_length", 2)
+        kwargs.setdefault("choices", choices.state_choices)
+        super().__init__(*args, **kwargs)
+        self.validators.append(validate_state)
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        kwargs.pop("choices", None)
+        if kwargs.get("max_length") == 2:
+            del kwargs["max_length"]
+        return name, path, args, kwargs
+
+
+class LGAField(models.CharField):
+    """Stores an LGA's P-code ("NG025011"), with all 774 LGAs (grouped by state) as choices."""
+
+    description = "Nigerian local government area"
+
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("max_length", 8)
+        kwargs.setdefault("choices", choices.lga_choices)
+        super().__init__(*args, **kwargs)
+        self.validators.append(validate_lga)
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        kwargs.pop("choices", None)
+        if kwargs.get("max_length") == 8:
+            del kwargs["max_length"]
+        return name, path, args, kwargs

django_naija-0.1.0/src/django_naija/forms.py

@@ -0,0 +1,135 @@
+"""Form fields and mixins.
+
+    from django_naija import forms as ngforms
+
+    class SignupForm(ngforms.StateLGAFormMixin, ngforms.NUBANFormMixin, forms.Form):
+        phone = ngforms.NigerianPhoneField(types=["mobile"])
+        state = ngforms.StateField()
+        lga = ngforms.LGAField()
+        bank = ngforms.BankField()
+        account_number = ngforms.NUBANField()
+"""
+
+from __future__ import annotations
+
+from typing import Optional, Sequence
+
+import naija_data as ng
+from django import forms
+from django.core.exceptions import ValidationError
+
+from . import choices
+from .validators import (NUBANValidator, PhoneValidator, PlateValidator, clean_nuban, validate_lga_in_state,
+                         validate_nuban_for_bank)
+
+
+class NigerianPhoneField(forms.CharField):
+    """Cleans to E.164, e.g. "+2348031234567". `types` restricts accepted number types."""
+
+    def __init__(self, *, types: Optional[Sequence[str]] = None, **kwargs):
+        kwargs.setdefault("max_length", 32)
+        super().__init__(**kwargs)
+        self.validators.append(PhoneValidator(types))
+        self.widget.attrs.setdefault("inputmode", "tel")
+        self.widget.attrs.setdefault("autocomplete", "tel")
+
+    def clean(self, value):
+        value = super().clean(value)
+        return ng.normalize_phone(value) if value else value
+
+
+class NUBANField(forms.CharField):
+    """A 10-digit account number; cleans to the digits only."""
+
+    def __init__(self, *, bank: Optional[str] = None, **kwargs):
+        kwargs.setdefault("max_length", 13)
+        super().__init__(**kwargs)
+        self.validators.append(NUBANValidator(bank))
+        self.widget.attrs.setdefault("inputmode", "numeric")
+
+    def clean(self, value):
+        value = super().clean(value)
+        return clean_nuban(value) if value else value
+
+
+class PlateNumberField(forms.CharField):
+    """A vehicle plate number; cleans to the display form, e.g. "KJA-123AB"."""
+
+    def __init__(self, *, formats: Optional[Sequence[str]] = None, **kwargs):
+        kwargs.setdefault("max_length", 16)
+        super().__init__(**kwargs)
+        self.validators.append(PlateValidator(formats))
+
+    def clean(self, value):
+        value = super().clean(value)
+        return ng.parse_plate(value).display if value else value
+
+
+class StateField(forms.ChoiceField):
+    """Choose a state; the value is its ISO 3166-2 code ("LA")."""
+
+    def __init__(self, **kwargs):
+        kwargs.setdefault("choices", choices.state_choices)
+        super().__init__(**kwargs)
+
+
+class LGAField(forms.ChoiceField):
+    """Choose an LGA; the value is its P-code ("NG025011"). Use with StateLGAFormMixin to limit the
+    choices to the selected state."""
+
+    def __init__(self, *, state: Optional[str] = None, **kwargs):
+        kwargs.setdefault("choices", (lambda: choices.lga_choices(state)) if state else choices.lga_choices)
+        super().__init__(**kwargs)
+
+
+class BankField(forms.ChoiceField):
+    """Choose a bank; the value is its naija-data id ("gtbank")."""
+
+    def __init__(self, *, types: Optional[Sequence[str]] = None, with_cbn_code_only: bool = True, **kwargs):
+        kwargs.setdefault("choices", lambda: choices.bank_choices(types, with_cbn_code_only))
+        super().__init__(**kwargs)
+
+
+class StateLGAFormMixin:
+    """Limits the LGA field's choices to the submitted (or initial) state and checks that the LGA
+    belongs to it. Set `state_field` / `lga_field` if your fields have other names."""
+
+    state_field = "state"
+    lga_field = "lga"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        state = None
+        if self.is_bound:
+            state = self.data.get(self.add_prefix(self.state_field))
+        state = state or self.initial.get(self.state_field) or self.fields[self.state_field].initial
+        if state and ng.get_state(str(state)):
+            self.fields[self.lga_field].choices = choices.lga_choices(state)
+
+    def clean(self):
+        data = super().clean()
+        state, lga = data.get(self.state_field), data.get(self.lga_field)
+        if state and lga:
+            try:
+                validate_lga_in_state(lga, state)
+            except ValidationError as e:
+                self.add_error(self.lga_field, e)
+        return data
+
+
+class NUBANFormMixin:
+    """Checks that the account number is valid for the selected bank (CBN check digit).
+    Set `nuban_field` / `bank_field` if your fields have other names."""
+
+    nuban_field = "account_number"
+    bank_field = "bank"
+
+    def clean(self):
+        data = super().clean()
+        account, bank = data.get(self.nuban_field), data.get(self.bank_field)
+        if account and bank:
+            try:
+                validate_nuban_for_bank(account, bank)
+            except ValidationError as e:
+                self.add_error(self.nuban_field if e.code == "check_digit" else self.bank_field, e)
+        return data

django_naija-0.1.0/src/django_naija/messages.py

@@ -0,0 +1,35 @@
+"""Human-readable, translatable error messages for each error code from naija-data."""
+
+from django.utils.translation import gettext_lazy as _
+
+PHONE_MESSAGES = {
+    "empty": _("Enter a phone number."),
+    "invalid_characters": _("A phone number can only contain digits, spaces, dashes, brackets and a leading +."),
+    "not_nigerian": _("Enter a Nigerian phone number (+234)."),
+    "bad_length": _("This phone number has the wrong number of digits."),
+    "unknown_prefix": _("This is not a Nigerian mobile prefix."),
+    "unallocated": _("This number range is not allocated to any network."),
+    "reserved": _("This number range is reserved and not in service."),
+    "unknown_area_code": _("This is not a Nigerian landline area code."),
+    "wrong_type": _("This type of phone number is not accepted here."),
+}
+
+PLATE_MESSAGES = {
+    "empty": _("Enter a plate number."),
+    "invalid_characters": _("A plate number can only contain letters, digits, spaces and dashes."),
+    "unknown_format": _("Enter a plate number like ABC-123DE."),
+    "unknown_state": _("This dealer plate does not start with D and a valid state code."),
+    "wrong_format": _("This type of plate number is not accepted here."),
+}
+
+NUBAN_MESSAGES = {
+    "format": _("Enter a 10-digit account number."),
+    "check_digit": _("This account number is not valid for the selected bank."),
+    "unknown_bank": _("Select a valid bank."),
+}
+
+ADMIN_MESSAGES = {
+    "unknown_state": _("Select a valid state."),
+    "unknown_lga": _("Select a valid local government area."),
+    "lga_not_in_state": _("This local government area is not in the selected state."),
+}

django_naija-0.1.0/src/django_naija/rest_framework.py

@@ -0,0 +1,140 @@
+"""Django REST framework serializer fields and validators.
+
+    from django_naija import rest_framework as ngdrf
+
+    class PayoutSerializer(serializers.Serializer):
+        phone = ngdrf.NigerianPhoneField(types=["mobile"])
+        state = ngdrf.StateField()
+        lga = ngdrf.LGAField()
+        bank = ngdrf.BankField()
+        account_number = ngdrf.NUBANField()
+
+        class Meta:
+            validators = [ngdrf.NUBANBankValidator(), ngdrf.LGAInStateValidator()]
+"""
+
+from __future__ import annotations
+
+from typing import Optional, Sequence
+
+import naija_data as ng
+from django.core.exceptions import ValidationError as DjangoValidationError
+from rest_framework import serializers
+
+from . import choices
+from .validators import (NUBANValidator, PhoneValidator, PlateValidator, clean_nuban, validate_lga_in_state,
+                         validate_nuban_for_bank)
+
+
+def _run(validator, value):
+    try:
+        validator(value)
+    except DjangoValidationError as e:
+        raise serializers.ValidationError(e.messages, code=e.code)
+
+
+class NigerianPhoneField(serializers.CharField):
+    """Accepts any common format; returns E.164 ("+2348031234567")."""
+
+    def __init__(self, *, types: Optional[Sequence[str]] = None, **kwargs):
+        self.phone_validator = PhoneValidator(types)
+        super().__init__(**kwargs)
+
+    def to_internal_value(self, data):
+        value = super().to_internal_value(data)
+        _run(self.phone_validator, value)
+        return ng.normalize_phone(value)
+
+
+class NUBANField(serializers.CharField):
+    """Returns the 10 digits of an account number."""
+
+    def __init__(self, *, bank: Optional[str] = None, **kwargs):
+        self.nuban_validator = NUBANValidator(bank)
+        super().__init__(**kwargs)
+
+    def to_internal_value(self, data):
+        value = super().to_internal_value(data)
+        _run(self.nuban_validator, value)
+        return clean_nuban(value)
+
+
+class PlateNumberField(serializers.CharField):
+    """Returns the plate's display form ("KJA-123AB")."""
+
+    def __init__(self, *, formats: Optional[Sequence[str]] = None, **kwargs):
+        self.plate_validator = PlateValidator(formats)
+        super().__init__(**kwargs)
+
+    def to_internal_value(self, data):
+        value = super().to_internal_value(data)
+        _run(self.plate_validator, value)
+        return ng.parse_plate(value).display
+
+
+class StateField(serializers.ChoiceField):
+    """A state's ISO 3166-2 code ("LA"). Also accepts names and aliases ("Lagos", "Abuja")."""
+
+    def __init__(self, **kwargs):
+        super().__init__(choices=choices.state_choices(), **kwargs)
+
+    def to_internal_value(self, data):
+        found = ng.get_state(str(data)) if data not in ("", None) else None
+        return super().to_internal_value(found.code if found else data)
+
+
+class LGAField(serializers.ChoiceField):
+    """An LGA's P-code ("NG025011"). Also accepts INEC codes ("24-11") and unambiguous names."""
+
+    def __init__(self, **kwargs):
+        super().__init__(choices=[c for _, group in choices.lga_choices() for c in group], **kwargs)
+
+    def to_internal_value(self, data):
+        found = ng.get_lga(str(data)) if data not in ("", None) else None
+        return super().to_internal_value(found.code if found else data)
+
+
+class BankField(serializers.ChoiceField):
+    """A bank's naija-data id ("gtbank"). Also accepts CBN codes ("058") and names ("GTB")."""
+
+    def __init__(self, *, types: Optional[Sequence[str]] = None, with_cbn_code_only: bool = True, **kwargs):
+        super().__init__(choices=choices.bank_choices(types, with_cbn_code_only), **kwargs)
+
+    def to_internal_value(self, data):
+        found = ng.get_bank(str(data)) if data not in ("", None) else None
+        return super().to_internal_value(found.id if found else data)
+
+
+class NUBANBankValidator:
+    """Serializer-level validator: the account number must be valid for the chosen bank."""
+
+    requires_context = False
+
+    def __init__(self, nuban_field: str = "account_number", bank_field: str = "bank"):
+        self.nuban_field, self.bank_field = nuban_field, bank_field
+
+    def __call__(self, attrs):
+        account, bank = attrs.get(self.nuban_field), attrs.get(self.bank_field)
+        if account and bank:
+            try:
+                validate_nuban_for_bank(account, bank)
+            except DjangoValidationError as e:
+                field = self.nuban_field if e.code == "check_digit" else self.bank_field
+                raise serializers.ValidationError({field: e.messages}, code=e.code)
+
+
+class LGAInStateValidator:
+    """Serializer-level validator: the LGA must be in the chosen state."""
+
+    requires_context = False
+
+    def __init__(self, state_field: str = "state", lga_field: str = "lga"):
+        self.state_field, self.lga_field = state_field, lga_field
+
+    def __call__(self, attrs):
+        state, lga = attrs.get(self.state_field), attrs.get(self.lga_field)
+        if state and lga:
+            try:
+                validate_lga_in_state(lga, state)
+            except DjangoValidationError as e:
+                raise serializers.ValidationError({self.lga_field: e.messages}, code=e.code)

django_naija-0.1.0/src/django_naija/validators.py

@@ -0,0 +1,104 @@
+"""Validators for model fields, form fields and serializers. All are deconstructible, so they can be
+used in migrations."""
+
+from __future__ import annotations
+
+import re
+from typing import Optional, Sequence
+
+import naija_data as ng
+from django.core.exceptions import ValidationError
+from django.utils.deconstruct import deconstructible
+
+from .messages import ADMIN_MESSAGES, NUBAN_MESSAGES, PHONE_MESSAGES, PLATE_MESSAGES
+
+
+@deconstructible
+class PhoneValidator:
+    """A valid Nigerian phone number, optionally only of some types (e.g. ("mobile",))."""
+
+    def __init__(self, types: Optional[Sequence[str]] = None):
+        self.types = tuple(types) if types else None
+
+    def __call__(self, value) -> None:
+        error = ng.phone_error(str(value))
+        if error:
+            raise ValidationError(PHONE_MESSAGES[error], code=error)
+        if self.types and ng.parse_phone(str(value)).type not in self.types:
+            raise ValidationError(PHONE_MESSAGES["wrong_type"], code="wrong_type")
+
+    def __eq__(self, other) -> bool:
+        return isinstance(other, PhoneValidator) and self.types == other.types
+
+
+@deconstructible
+class PlateValidator:
+    """A valid vehicle plate number, optionally only of some formats (e.g. ("standard",))."""
+
+    def __init__(self, formats: Optional[Sequence[str]] = None):
+        self.formats = tuple(formats) if formats else None
+
+    def __call__(self, value) -> None:
+        error = ng.plate_error(str(value))
+        if error:
+            raise ValidationError(PLATE_MESSAGES[error], code=error)
+        if self.formats and ng.parse_plate(str(value)).format not in self.formats:
+            raise ValidationError(PLATE_MESSAGES["wrong_format"], code="wrong_format")
+
+    def __eq__(self, other) -> bool:
+        return isinstance(other, PlateValidator) and self.formats == other.formats
+
+
+def clean_nuban(value) -> str:
+    """The 10 digits of an account number, without spaces or dashes."""
+    return re.sub(r"[\s-]", "", str(value))
+
+
+@deconstructible
+class NUBANValidator:
+    """A 10-digit NUBAN account number. With `bank` (CBN code, id or name) the CBN check digit is
+    checked too; to check against a bank chosen in the same form, use NUBANFormMixin."""
+
+    def __init__(self, bank: Optional[str] = None):
+        self.bank = bank
+
+    def __call__(self, value) -> None:
+        if not re.fullmatch(r"\d{10}", clean_nuban(value)):
+            raise ValidationError(NUBAN_MESSAGES["format"], code="format")
+        if self.bank and not ng.is_valid_nuban(clean_nuban(value), self.bank):
+            raise ValidationError(NUBAN_MESSAGES["check_digit"], code="check_digit")
+
+    def __eq__(self, other) -> bool:
+        return isinstance(other, NUBANValidator) and self.bank == other.bank
+
+
+def validate_nuban_for_bank(account, bank) -> None:
+    """Raise ValidationError unless `account` has a valid check digit for `bank`."""
+    found = ng.get_bank(str(bank)) if bank else None
+    if found is None or not found.cbn_code:
+        raise ValidationError(NUBAN_MESSAGES["unknown_bank"], code="unknown_bank")
+    NUBANValidator()(account)
+    if not ng.is_valid_nuban(clean_nuban(account), found.cbn_code):
+        raise ValidationError(NUBAN_MESSAGES["check_digit"], code="check_digit")
+
+
+def validate_state(value) -> None:
+    if ng.get_state(str(value)) is None:
+        raise ValidationError(ADMIN_MESSAGES["unknown_state"], code="unknown_state")
+
+
+def validate_lga(value) -> None:
+    if ng.get_lga(str(value)) is None:
+        raise ValidationError(ADMIN_MESSAGES["unknown_lga"], code="unknown_lga")
+
+
+def validate_lga_in_state(lga, state) -> None:
+    """Raise ValidationError unless the LGA (code or name) is in the state."""
+    st = ng.get_state(str(state)) if state else None
+    if st is None:
+        raise ValidationError(ADMIN_MESSAGES["unknown_state"], code="unknown_state")
+    found = ng.get_lga(str(lga), st)
+    if found is None:
+        raise ValidationError(ADMIN_MESSAGES["unknown_lga"], code="unknown_lga")
+    if found.state_code != st.code:
+        raise ValidationError(ADMIN_MESSAGES["lga_not_in_state"], code="lga_not_in_state")

django_naija-0.1.0/tests/test_django_naija.py

@@ -0,0 +1,161 @@
+import pytest
+from django.core.exceptions import ValidationError
+from django.core.management import call_command
+from rest_framework.test import APIClient
+
+from django_naija import forms as ngforms
+from django_naija.choices import bank_choices, lga_choices, state_choices
+from django_naija.validators import NUBANValidator, PhoneValidator, PlateValidator, validate_nuban_for_bank
+from shop.forms import CustomerForm
+from shop.models import Customer
+
+VALID = {"name": "Ada", "phone": "0803 123 4567", "state": "LA", "lga": "NG025011", "plate": "kja 123 ab",
+         "bank": "first-bank", "account_number": "000 001 4579"}  # CBN example: bank 011, serial 000001457
+
+
+# ---- validators
+
+@pytest.mark.parametrize("value, code", [("0900 123 4567", "reserved"), ("0910 123 4567", "unknown_prefix"),
+                                          ("+1 202 555 0100", "not_nigerian"), ("01 269 1531", "wrong_type")])
+def test_phone_validator_codes(value, code):
+    with pytest.raises(ValidationError) as e:
+        PhoneValidator(["mobile"])(value)
+    assert e.value.code == code
+
+
+def test_validators_accept_valid_values():
+    PhoneValidator()("01 269 1531")
+    PlateValidator()("DKN 135 3")
+    NUBANValidator(bank="011")("0000014579")
+    validate_nuban_for_bank("0000014579", "First Bank")
+
+
+def test_nuban_validators_reject():
+    with pytest.raises(ValidationError) as e:
+        NUBANValidator()("12345")
+    assert e.value.code == "format"
+    with pytest.raises(ValidationError) as e:
+        validate_nuban_for_bank("0000014578", "011")
+    assert e.value.code == "check_digit"
+    with pytest.raises(ValidationError) as e:
+        validate_nuban_for_bank("0000014579", "Atlantis Bank")
+    assert e.value.code == "unknown_bank"
+
+
+def test_validators_are_deconstructible():
+    path, args, kwargs = PhoneValidator(["mobile"]).deconstruct()
+    assert path == "django_naija.validators.PhoneValidator"
+    assert (args, kwargs) == ((["mobile"],), {})
+    assert PhoneValidator(["mobile"]) == PhoneValidator(("mobile",))
+
+
+# ---- choices
+
+def test_choices():
+    assert len(state_choices()) == 37
+    assert ("LA", "Lagos") in state_choices()
+    assert len(lga_choices("LA")) == 20
+    assert sum(len(group) for _, group in lga_choices()) == 774
+    assert ("gtbank", "GTBank") in bank_choices(with_cbn_code_only=True)
+
+
+# ---- forms
+
+def test_form_cleans_and_normalises():
+    form = CustomerForm(VALID)
+    assert form.is_valid(), form.errors
+    assert form.cleaned_data["phone"] == "+2348031234567"
+    assert form.cleaned_data["plate"] == "KJA-123AB"
+    assert form.cleaned_data["account_number"] == "0000014579"
+
+
+def test_form_limits_lgas_to_state():
+    form = CustomerForm({**VALID, "lga": "NG031033"})  # Surulere, Oyo: not in Lagos
+    assert not form.is_valid()
+    assert "lga" in form.errors
+    assert len(form.fields["lga"].choices) == 20
+
+
+def test_form_checks_account_against_bank():
+    form = CustomerForm({**VALID, "account_number": "0000014578"})
+    assert not form.is_valid()
+    assert "not valid for the selected bank" in form.errors["account_number"][0]
+
+
+def test_form_error_messages_are_clear():
+    form = CustomerForm({**VALID, "phone": "0900 123 4567"})
+    assert not form.is_valid()
+    assert form.errors["phone"] == ["This number range is reserved and not in service."]
+
+
+def test_standalone_form_fields():
+    assert ngforms.NigerianPhoneField().clean("+234 (0) 803 123 4567") == "+2348031234567"
+    assert ngforms.PlateNumberField(formats=["dealer"]).clean("dla5481") == "DLA 548 1"
+    with pytest.raises(ValidationError):
+        ngforms.PlateNumberField(formats=["dealer"]).clean("KJA-123AB")
+
+
+# ---- models (database)
+
+@pytest.mark.django_db
+def test_model_stores_canonical_values():
+    c = Customer(name="Ada", phone="0803 123 4567", state="LA", lga="NG025011", plate="kja 123 ab",
+                 account_number="000 001 4579")
+    c.full_clean()
+    c.save()
+    row = Customer.objects.values("phone", "plate", "account_number").get(pk=c.pk)
+    assert row == {"phone": "+2348031234567", "plate": "KJA123AB", "account_number": "0000014579"}
+    assert Customer.objects.filter(phone="08031234567").exists()  # lookups are normalised too
+
+
+@pytest.mark.django_db
+def test_model_full_clean_rejects_bad_values():
+    c = Customer(name="Bad", phone="01 269 1531", state="ZZ", lga="NG999999")
+    with pytest.raises(ValidationError) as e:
+        c.full_clean()
+    assert set(e.value.message_dict) >= {"phone", "state", "lga"}
+
+
+@pytest.mark.django_db
+def test_migrations_are_up_to_date():
+    call_command("makemigrations", "shop", "--check", "--dry-run")
+
+
+# ---- views and DRF
+
+@pytest.mark.django_db
+def test_dependent_lga_endpoint(client):
+    data = client.get("/lgas/", {"state": "Lagos"}).json()
+    assert data["state"] == "LA" and len(data["lgas"]) == 20
+    assert client.get("/lgas/", {"state": "Atlantis"}).status_code == 404
+
+
+@pytest.mark.django_db
+def test_signup_view(client):
+    assert client.post("/signup/", VALID).status_code == 201
+    assert Customer.objects.get().phone == "+2348031234567"
+
+
+@pytest.mark.django_db
+def test_drf_accepts_names_and_normalises():
+    api = APIClient()
+    payload = {"name": "Ada", "phone": "+234 803 123 4567", "state": "Lagos", "lga": "24-11", "plate": "kja123ab",
+               "bank": "First Bank", "account_number": "0000014579"}
+    r = api.post("/api/customers/", payload, format="json")
+    assert r.status_code == 201, r.json()
+    body = r.json()
+    assert (body["phone"], body["state"], body["lga"], body["bank"]) == ("+2348031234567", "LA", "NG025011", "first-bank")
+
+
+@pytest.mark.django_db
+def test_drf_errors_point_at_the_right_field():
+    api = APIClient()
+    bad_account = {"name": "Ada", "phone": "08031234567", "state": "LA", "lga": "NG025011", "bank": "011",
+                   "account_number": "0000014578"}
+    r = api.post("/api/customers/", bad_account, format="json")
+    assert r.status_code == 400 and "account_number" in r.json()
+    wrong_state = {**bad_account, "account_number": "0000014579", "lga": "NG031033"}
+    r = api.post("/api/customers/", wrong_state, format="json")
+    assert r.status_code == 400 and "lga" in r.json()
+    r = api.post("/api/customers/", {**wrong_state, "lga": "NG025011", "phone": "0900 123 4567"}, format="json")
+    assert r.json()["phone"] == ["This number range is reserved and not in service."]