django-bidi-input 1.0.0__tar.gz

django_bidi_input-1.0.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: django-bidi-input
+Version: 1.0.0
+Summary: Force correct text direction (LTR/RTL) on Django admin and form input fields, regardless of site language.
+Author-email: Omid Shojaee <omid.shojaee@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/omidshojaee/django-bidi-input
+Project-URL: Issues, https://github.com/omidshojaee/django-bidi-input/issues
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: Django>=5.2
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: pytest-django>=4; extra == "test"
+
+# django-bidi-input
+
+Django doesn't let you control the text direction of individual form/admin
+input fields — when a site's language is RTL (Farsi, Arabic, Hebrew, ...),
+every input renders RTL, including fields where that's wrong: email, URL,
+slug, UUID, IP address, numbers, passwords, phone numbers, etc. Only free
+text fields should follow the page direction.
+
+This has been an accepted Django ticket
+([#35482](https://code.djangoproject.com/ticket/35482)) for a while with no
+implementation yet. `django-bidi-input` fixes it today, without patching
+Django, for both **admin** and regular **forms**.
+
+## Install
+
+```bash
+pip install django-bidi-input
+```
+
+```python
+INSTALLED_APPS = [
+    ...,
+    "django_bidi_input",
+]
+```
+
+That's it. Every `ModelForm`, plain `Form`, and admin form in your project
+now gets a correct `dir` attribute (and a `bidi-input-ltr`/`bidi-input-rtl`
+CSS class as a fallback) on each field, automatically.
+
+## How direction is decided
+
+For each field, in order (first match wins):
+
+1. You already set `dir` on the widget yourself — left untouched.
+2. `direction` set directly on the model field instance:
+   ```python
+   phone_number = models.CharField(max_length=32)
+   phone_number.direction = "ltr"
+   ```
+3. `BIDI_INPUT_OVERRIDES` setting, for fields you can't edit directly
+   (third-party app models, etc.):
+   ```python
+   BIDI_INPUT_OVERRIDES = {
+       "myapp.Contact.phone_number": "ltr",
+   }
+   ```
+4. Built-in default, in order:
+   - widget `input_type` is `password`, `number`, `tel`, `date`, `time`, etc.
+   - widget `autocomplete` is `username`, `email`, `tel`, `new-password`,
+     `current-password`, `one-time-code`. This is what makes Django's own
+     admin/auth **login form** (`username` + `password`) render LTR, even
+     though `UsernameField` is a plain `CharField` — Django sets
+     `autocomplete="username"` on it unconditionally, including when a
+     custom user model uses `USERNAME_FIELD = "email"`.
+   - field class is `EmailField`, `URLField`, `SlugField`, `UUIDField`,
+     `GenericIPAddressField`, `FilePathField`, `IntegerField`, `FloatField`,
+     `DecimalField`, `DurationField`, `RegexField`.
+5. Otherwise left alone — inherits the page's direction (correct for plain
+   `CharField`/`TextField`).
+
+## Settings
+
+| Setting | Default | Purpose |
+|---|---|---|
+| `BIDI_INPUT_ENABLED` | `True` | Turn the whole thing off. |
+| `BIDI_INPUT_OVERRIDES` | `{}` | `"app_label.Model.field": "ltr"/"rtl"` map. |
+| `BIDI_INPUT_LTR_FIELD_CLASSES` | see `conf.py` | Dotted paths of extra form field classes to treat as LTR. |
+| `BIDI_INPUT_LTR_INPUT_TYPES` | see `conf.py` | Extra widget `input_type` values to treat as LTR. |
+| `BIDI_INPUT_LTR_AUTOCOMPLETE_VALUES` | see `conf.py` | Extra widget `autocomplete` values to treat as LTR. |
+
+## Why this works for admin too
+
+Django admin builds its forms as ordinary `ModelForm` subclasses via
+`modelform_factory`. This package hooks `BaseForm.__init__` once, so admin
+inherits the behavior automatically — no `ModelAdmin` changes needed.
+
+## Scope
+
+This targets the actual pain point: **Django admin and Django forms**.
+It does not attempt to make `direction` a real `Field` kwarg (that requires
+changing Django itself, which is what ticket #35482 is for), so
+introspection-based tools built outside the forms API (DRF serializers,
+etc.) won't see it.
+
+## Running the tests
+
+```bash
+pip install -e ".[test]"
+pytest
+```

django_bidi_input-1.0.0/README.md

@@ -0,0 +1,91 @@
+# django-bidi-input
+
+Django doesn't let you control the text direction of individual form/admin
+input fields — when a site's language is RTL (Farsi, Arabic, Hebrew, ...),
+every input renders RTL, including fields where that's wrong: email, URL,
+slug, UUID, IP address, numbers, passwords, phone numbers, etc. Only free
+text fields should follow the page direction.
+
+This has been an accepted Django ticket
+([#35482](https://code.djangoproject.com/ticket/35482)) for a while with no
+implementation yet. `django-bidi-input` fixes it today, without patching
+Django, for both **admin** and regular **forms**.
+
+## Install
+
+```bash
+pip install django-bidi-input
+```
+
+```python
+INSTALLED_APPS = [
+    ...,
+    "django_bidi_input",
+]
+```
+
+That's it. Every `ModelForm`, plain `Form`, and admin form in your project
+now gets a correct `dir` attribute (and a `bidi-input-ltr`/`bidi-input-rtl`
+CSS class as a fallback) on each field, automatically.
+
+## How direction is decided
+
+For each field, in order (first match wins):
+
+1. You already set `dir` on the widget yourself — left untouched.
+2. `direction` set directly on the model field instance:
+   ```python
+   phone_number = models.CharField(max_length=32)
+   phone_number.direction = "ltr"
+   ```
+3. `BIDI_INPUT_OVERRIDES` setting, for fields you can't edit directly
+   (third-party app models, etc.):
+   ```python
+   BIDI_INPUT_OVERRIDES = {
+       "myapp.Contact.phone_number": "ltr",
+   }
+   ```
+4. Built-in default, in order:
+   - widget `input_type` is `password`, `number`, `tel`, `date`, `time`, etc.
+   - widget `autocomplete` is `username`, `email`, `tel`, `new-password`,
+     `current-password`, `one-time-code`. This is what makes Django's own
+     admin/auth **login form** (`username` + `password`) render LTR, even
+     though `UsernameField` is a plain `CharField` — Django sets
+     `autocomplete="username"` on it unconditionally, including when a
+     custom user model uses `USERNAME_FIELD = "email"`.
+   - field class is `EmailField`, `URLField`, `SlugField`, `UUIDField`,
+     `GenericIPAddressField`, `FilePathField`, `IntegerField`, `FloatField`,
+     `DecimalField`, `DurationField`, `RegexField`.
+5. Otherwise left alone — inherits the page's direction (correct for plain
+   `CharField`/`TextField`).
+
+## Settings
+
+| Setting | Default | Purpose |
+|---|---|---|
+| `BIDI_INPUT_ENABLED` | `True` | Turn the whole thing off. |
+| `BIDI_INPUT_OVERRIDES` | `{}` | `"app_label.Model.field": "ltr"/"rtl"` map. |
+| `BIDI_INPUT_LTR_FIELD_CLASSES` | see `conf.py` | Dotted paths of extra form field classes to treat as LTR. |
+| `BIDI_INPUT_LTR_INPUT_TYPES` | see `conf.py` | Extra widget `input_type` values to treat as LTR. |
+| `BIDI_INPUT_LTR_AUTOCOMPLETE_VALUES` | see `conf.py` | Extra widget `autocomplete` values to treat as LTR. |
+
+## Why this works for admin too
+
+Django admin builds its forms as ordinary `ModelForm` subclasses via
+`modelform_factory`. This package hooks `BaseForm.__init__` once, so admin
+inherits the behavior automatically — no `ModelAdmin` changes needed.
+
+## Scope
+
+This targets the actual pain point: **Django admin and Django forms**.
+It does not attempt to make `direction` a real `Field` kwarg (that requires
+changing Django itself, which is what ticket #35482 is for), so
+introspection-based tools built outside the forms API (DRF serializers,
+etc.) won't see it.
+
+## Running the tests
+
+```bash
+pip install -e ".[test]"
+pytest
+```

django_bidi_input-1.0.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "django-bidi-input"
+version = "1.0.0"
+description = "Force correct text direction (LTR/RTL) on Django admin and form input fields, regardless of site language."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Omid Shojaee", email = "omid.shojaee@gmail.com" }]
+requires-python = ">=3.10"
+dependencies = ["Django>=5.2"]
+classifiers = [
+    "Framework :: Django",
+    "Framework :: Django :: 5.2",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=7", "pytest-django>=4"]
+
+[project.urls]
+Homepage = "https://github.com/omidshojaee/django-bidi-input"
+Issues = "https://github.com/omidshojaee/django-bidi-input/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+DJANGO_SETTINGS_MODULE = "tests.settings"
+python_files = ["test_*.py"]
+pythonpath = ["."]

django_bidi_input-1.0.0/setup.cfg

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

django_bidi_input-1.0.0/src/django_bidi_input/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

django_bidi_input-1.0.0/src/django_bidi_input/apply.py

@@ -0,0 +1,25 @@
+from . import conf
+from .direction import resolve_direction
+
+
+def apply_directions(form):
+    if not conf.is_enabled():
+        return
+
+    model = getattr(getattr(form, "_meta", None), "model", None)
+
+    for field_name, field in form.fields.items():
+        attrs = field.widget.attrs
+
+        if attrs.get("dir"):
+            continue
+
+        direction = resolve_direction(field, field_name, model=model)
+        if direction is None:
+            continue
+
+        attrs["dir"] = direction
+        css_class = attrs.get("class", "")
+        marker = "bidi-input-{}".format(direction)
+        if marker not in css_class.split():
+            attrs["class"] = "{} {}".format(css_class, marker).strip()

django_bidi_input-1.0.0/src/django_bidi_input/apps.py

@@ -0,0 +1,12 @@
+from django.apps import AppConfig
+
+
+class BidiInputConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "django_bidi_input"
+    verbose_name = "Bidi Input"
+
+    def ready(self):
+        from . import patch
+
+        patch.install()

django_bidi_input-1.0.0/src/django_bidi_input/conf.py

@@ -0,0 +1,76 @@
+from django.conf import settings
+from django.utils.module_loading import import_string
+
+DEFAULT_LTR_FIELD_PATHS = [
+    "django.forms.EmailField",
+    "django.forms.URLField",
+    "django.forms.SlugField",
+    "django.forms.UUIDField",
+    "django.forms.GenericIPAddressField",
+    "django.forms.FilePathField",
+    "django.forms.IntegerField",
+    "django.forms.FloatField",
+    "django.forms.DecimalField",
+    "django.forms.DurationField",
+    "django.forms.RegexField",
+]
+
+DEFAULT_LTR_INPUT_TYPES = {
+    "email",
+    "url",
+    "number",
+    "password",
+    "tel",
+    "date",
+    "time",
+    "datetime-local",
+    "month",
+    "week",
+    "color",
+}
+
+DEFAULT_LTR_AUTOCOMPLETE_VALUES = {
+    "username",
+    "email",
+    "tel",
+    "new-password",
+    "current-password",
+    "one-time-code",
+}
+
+
+def _import_all(dotted_paths):
+    classes = []
+    for path in dotted_paths:
+        try:
+            classes.append(import_string(path))
+        except ImportError:
+            continue
+    return tuple(classes)
+
+
+def get_ltr_field_classes():
+    paths = getattr(settings, "BIDI_INPUT_LTR_FIELD_CLASSES", DEFAULT_LTR_FIELD_PATHS)
+    return _import_all(paths)
+
+
+def get_ltr_input_types():
+    return set(getattr(settings, "BIDI_INPUT_LTR_INPUT_TYPES", DEFAULT_LTR_INPUT_TYPES))
+
+
+def get_ltr_autocomplete_values():
+    return set(
+        getattr(
+            settings,
+            "BIDI_INPUT_LTR_AUTOCOMPLETE_VALUES",
+            DEFAULT_LTR_AUTOCOMPLETE_VALUES,
+        )
+    )
+
+
+def get_overrides():
+    return getattr(settings, "BIDI_INPUT_OVERRIDES", {})
+
+
+def is_enabled():
+    return getattr(settings, "BIDI_INPUT_ENABLED", True)

django_bidi_input-1.0.0/src/django_bidi_input/direction.py

@@ -0,0 +1,47 @@
+from django.core.exceptions import FieldDoesNotExist
+
+from . import conf
+
+LTR = "ltr"
+RTL = "rtl"
+VALID_DIRECTIONS = (LTR, RTL)
+
+
+def _override_key(model, field_name):
+    return "{}.{}.{}".format(model._meta.app_label, model._meta.object_name, field_name)
+
+
+def _model_field_for(model, field_name):
+    if model is None:
+        return None
+    try:
+        return model._meta.get_field(field_name)
+    except FieldDoesNotExist:
+        return None
+
+
+def resolve_direction(form_field, field_name, model=None):
+    model_field = _model_field_for(model, field_name)
+
+    if model_field is not None:
+        direction = getattr(model_field, "direction", None)
+        if direction in VALID_DIRECTIONS:
+            return direction
+
+    if model is not None:
+        override = conf.get_overrides().get(_override_key(model, field_name))
+        if override in VALID_DIRECTIONS:
+            return override
+
+    input_type = getattr(form_field.widget, "input_type", None)
+    if input_type in conf.get_ltr_input_types():
+        return LTR
+
+    autocomplete = form_field.widget.attrs.get("autocomplete")
+    if autocomplete in conf.get_ltr_autocomplete_values():
+        return LTR
+
+    if isinstance(form_field, conf.get_ltr_field_classes()):
+        return LTR
+
+    return None

django_bidi_input-1.0.0/src/django_bidi_input/patch.py

@@ -0,0 +1,19 @@
+from django.forms.forms import BaseForm
+
+from .apply import apply_directions
+
+_PATCHED_ATTR = "_bidi_input_patched"
+
+
+def install():
+    if getattr(BaseForm.__init__, _PATCHED_ATTR, False):
+        return
+
+    original_init = BaseForm.__init__
+
+    def patched_init(self, *args, **kwargs):
+        original_init(self, *args, **kwargs)
+        apply_directions(self)
+
+    setattr(patched_init, _PATCHED_ATTR, True)
+    BaseForm.__init__ = patched_init

django_bidi_input-1.0.0/src/django_bidi_input.egg-info/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: django-bidi-input
+Version: 1.0.0
+Summary: Force correct text direction (LTR/RTL) on Django admin and form input fields, regardless of site language.
+Author-email: Omid Shojaee <omid.shojaee@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/omidshojaee/django-bidi-input
+Project-URL: Issues, https://github.com/omidshojaee/django-bidi-input/issues
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: Django>=5.2
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: pytest-django>=4; extra == "test"
+
+# django-bidi-input
+
+Django doesn't let you control the text direction of individual form/admin
+input fields — when a site's language is RTL (Farsi, Arabic, Hebrew, ...),
+every input renders RTL, including fields where that's wrong: email, URL,
+slug, UUID, IP address, numbers, passwords, phone numbers, etc. Only free
+text fields should follow the page direction.
+
+This has been an accepted Django ticket
+([#35482](https://code.djangoproject.com/ticket/35482)) for a while with no
+implementation yet. `django-bidi-input` fixes it today, without patching
+Django, for both **admin** and regular **forms**.
+
+## Install
+
+```bash
+pip install django-bidi-input
+```
+
+```python
+INSTALLED_APPS = [
+    ...,
+    "django_bidi_input",
+]
+```
+
+That's it. Every `ModelForm`, plain `Form`, and admin form in your project
+now gets a correct `dir` attribute (and a `bidi-input-ltr`/`bidi-input-rtl`
+CSS class as a fallback) on each field, automatically.
+
+## How direction is decided
+
+For each field, in order (first match wins):
+
+1. You already set `dir` on the widget yourself — left untouched.
+2. `direction` set directly on the model field instance:
+   ```python
+   phone_number = models.CharField(max_length=32)
+   phone_number.direction = "ltr"
+   ```
+3. `BIDI_INPUT_OVERRIDES` setting, for fields you can't edit directly
+   (third-party app models, etc.):
+   ```python
+   BIDI_INPUT_OVERRIDES = {
+       "myapp.Contact.phone_number": "ltr",
+   }
+   ```
+4. Built-in default, in order:
+   - widget `input_type` is `password`, `number`, `tel`, `date`, `time`, etc.
+   - widget `autocomplete` is `username`, `email`, `tel`, `new-password`,
+     `current-password`, `one-time-code`. This is what makes Django's own
+     admin/auth **login form** (`username` + `password`) render LTR, even
+     though `UsernameField` is a plain `CharField` — Django sets
+     `autocomplete="username"` on it unconditionally, including when a
+     custom user model uses `USERNAME_FIELD = "email"`.
+   - field class is `EmailField`, `URLField`, `SlugField`, `UUIDField`,
+     `GenericIPAddressField`, `FilePathField`, `IntegerField`, `FloatField`,
+     `DecimalField`, `DurationField`, `RegexField`.
+5. Otherwise left alone — inherits the page's direction (correct for plain
+   `CharField`/`TextField`).
+
+## Settings
+
+| Setting | Default | Purpose |
+|---|---|---|
+| `BIDI_INPUT_ENABLED` | `True` | Turn the whole thing off. |
+| `BIDI_INPUT_OVERRIDES` | `{}` | `"app_label.Model.field": "ltr"/"rtl"` map. |
+| `BIDI_INPUT_LTR_FIELD_CLASSES` | see `conf.py` | Dotted paths of extra form field classes to treat as LTR. |
+| `BIDI_INPUT_LTR_INPUT_TYPES` | see `conf.py` | Extra widget `input_type` values to treat as LTR. |
+| `BIDI_INPUT_LTR_AUTOCOMPLETE_VALUES` | see `conf.py` | Extra widget `autocomplete` values to treat as LTR. |
+
+## Why this works for admin too
+
+Django admin builds its forms as ordinary `ModelForm` subclasses via
+`modelform_factory`. This package hooks `BaseForm.__init__` once, so admin
+inherits the behavior automatically — no `ModelAdmin` changes needed.
+
+## Scope
+
+This targets the actual pain point: **Django admin and Django forms**.
+It does not attempt to make `direction` a real `Field` kwarg (that requires
+changing Django itself, which is what ticket #35482 is for), so
+introspection-based tools built outside the forms API (DRF serializers,
+etc.) won't see it.
+
+## Running the tests
+
+```bash
+pip install -e ".[test]"
+pytest
+```

django_bidi_input-1.0.0/src/django_bidi_input.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/django_bidi_input/__init__.py
+src/django_bidi_input/apply.py
+src/django_bidi_input/apps.py
+src/django_bidi_input/conf.py
+src/django_bidi_input/direction.py
+src/django_bidi_input/patch.py
+src/django_bidi_input.egg-info/PKG-INFO
+src/django_bidi_input.egg-info/SOURCES.txt
+src/django_bidi_input.egg-info/dependency_links.txt
+src/django_bidi_input.egg-info/requires.txt
+src/django_bidi_input.egg-info/top_level.txt
+tests/test_admin.py
+tests/test_forms.py

django_bidi_input-1.0.0/src/django_bidi_input.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django_bidi_input-1.0.0/src/django_bidi_input.egg-info/requires.txt

@@ -0,0 +1,5 @@
+Django>=5.2
+
+[test]
+pytest>=7
+pytest-django>=4

django_bidi_input-1.0.0/src/django_bidi_input.egg-info/top_level.txt

@@ -0,0 +1 @@
+django_bidi_input

django_bidi_input-1.0.0/tests/test_admin.py

@@ -0,0 +1,25 @@
+import pytest
+from django.contrib.admin.sites import AdminSite
+
+from tests.testapp.admin import ContactAdmin, ProfileAdmin
+from tests.testapp.models import Contact, Profile
+
+
+@pytest.mark.django_db
+def test_admin_form_gets_directions_without_any_admin_config():
+    admin = ContactAdmin(Contact, AdminSite())
+    form_class = admin.get_form(request=None)
+    form = form_class()
+
+    assert "dir" not in form.fields["full_name"].widget.attrs
+    assert form.fields["email"].widget.attrs["dir"] == "ltr"
+    assert form.fields["notes"].widget.attrs["dir"] == "rtl"
+
+
+@pytest.mark.django_db
+def test_admin_form_picks_up_settings_override():
+    admin = ProfileAdmin(Profile, AdminSite())
+    form_class = admin.get_form(request=None)
+    form = form_class()
+
+    assert form.fields["bio"].widget.attrs["dir"] == "ltr"

django_bidi_input-1.0.0/tests/test_forms.py

@@ -0,0 +1,97 @@
+from django import forms
+import pytest
+
+from tests.testapp.models import Contact, Profile
+
+
+class ContactForm(forms.ModelForm):
+    class Meta:
+        model = Contact
+        fields = [
+            "full_name",
+            "email",
+            "website",
+            "slug",
+            "reference_id",
+            "ip_address",
+            "age",
+            "notes",
+            "phone_number",
+        ]
+
+
+class ProfileForm(forms.ModelForm):
+    class Meta:
+        model = Profile
+        fields = ["bio"]
+
+
+class PlainForm(forms.Form):
+    subject = forms.CharField()
+    contact_email = forms.EmailField()
+    password = forms.CharField(widget=forms.PasswordInput)
+
+
+@pytest.mark.django_db
+def test_plain_text_field_is_left_alone():
+    form = ContactForm()
+    assert "dir" not in form.fields["full_name"].widget.attrs
+
+
+@pytest.mark.django_db
+@pytest.mark.parametrize(
+    "field_name",
+    ["email", "website", "slug", "reference_id", "ip_address", "age"],
+)
+def test_builtin_heuristic_defaults_to_ltr(field_name):
+    form = ContactForm()
+    assert form.fields[field_name].widget.attrs["dir"] == "ltr"
+
+
+@pytest.mark.django_db
+def test_explicit_model_field_override_rtl():
+    form = ContactForm()
+    assert form.fields["notes"].widget.attrs["dir"] == "rtl"
+
+
+@pytest.mark.django_db
+def test_explicit_model_field_override_ltr_for_plain_charfield():
+    # phone_number is a bare CharField; only the .direction attribute
+    # set on the model field in models.py makes it LTR.
+    form = ContactForm()
+    assert form.fields["phone_number"].widget.attrs["dir"] == "ltr"
+
+
+@pytest.mark.django_db
+def test_settings_override_map():
+    form = ProfileForm()
+    assert form.fields["bio"].widget.attrs["dir"] == "ltr"
+
+
+def test_plain_non_model_form_uses_class_based_heuristic():
+    form = PlainForm()
+    assert "dir" not in form.fields["subject"].widget.attrs
+    assert form.fields["contact_email"].widget.attrs["dir"] == "ltr"
+    assert form.fields["password"].widget.attrs["dir"] == "ltr"
+
+
+def test_admin_login_form_username_and_password_are_ltr():
+    from django.contrib.auth.forms import AuthenticationForm
+
+    form = AuthenticationForm()
+    # UsernameField is a plain CharField -- only the autocomplete="username"
+    # token (set by Django itself) makes this resolve to LTR. This also
+    # covers a custom user model with USERNAME_FIELD = "email": Django's
+    # AuthenticationForm always uses UsernameField regardless of the
+    # underlying model field type, so the field-class heuristic alone
+    # would never catch it.
+    assert form.fields["username"].widget.attrs["dir"] == "ltr"
+    assert form.fields["password"].widget.attrs["dir"] == "ltr"
+
+
+def test_developer_set_dir_is_never_overwritten():
+    class ExplicitForm(forms.Form):
+        note = forms.CharField(widget=forms.TextInput(attrs={"dir": "rtl"}))
+
+    form = ExplicitForm()
+    assert form.fields["note"].widget.attrs["dir"] == "rtl"