Allow TAG fields to be sortable

RediSearch now supports SORTABLE on TAG fields. Remove restrictions that prevented TAG fields from being sortable in JsonModel. Update documentation to reflect that all field types (TAG, TEXT, NUMERIC, GEO) support sorting. Add regression test for TAG field sortability.

Author: abrookins

aredis_om/model/cli/migrate_data.py

@@ -605,14 +605,18 @@ async def check_schema_async():
         detector = DatetimeFieldDetector(migrator.redis)
         result = await detector.check_for_schema_mismatches(models)
 
-        if not result['has_mismatches']:
-            click.echo("✅ No schema mismatches detected - all datetime fields are properly indexed")
+        if not result["has_mismatches"]:
+            click.echo(
+                "✅ No schema mismatches detected - all datetime fields are properly indexed"
+            )
             return
 
-        click.echo(f"⚠️  Found {len(result['mismatches'])} datetime field schema mismatch(es):")
+        click.echo(
+            f"⚠️  Found {len(result['mismatches'])} datetime field schema mismatch(es):"
+        )
         click.echo()
 
-        for mismatch in result['mismatches']:
+        for mismatch in result["mismatches"]:
             click.echo(f"  Model: {mismatch['model']}")
             click.echo(f"  Field: {mismatch['field']}")
             click.echo(f"  Current Redis type: {mismatch['current_type']}")
@@ -621,12 +625,14 @@ async def check_schema_async():
             click.echo()
 
         click.echo("🚨 CRITICAL ISSUE DETECTED:")
-        click.echo(result['recommendation'])
+        click.echo(result["recommendation"])
         click.echo()
         click.echo("To fix this issue, run:")
         click.echo("  om migrate-data datetime")
         click.echo()
-        click.echo("This will convert your datetime fields from TAG to NUMERIC indexing,")
+        click.echo(
+            "This will convert your datetime fields from TAG to NUMERIC indexing,"
+        )
         click.echo("enabling proper range queries and sorting.")
 
         raise click.ClickException("Schema mismatches detected")

aredis_om/model/encoders.py

@@ -33,13 +33,16 @@
 
 from pydantic import BaseModel
 
+
 try:
     from pydantic.deprecated.json import ENCODERS_BY_TYPE
     from pydantic_core import PydanticUndefined
+
     PYDANTIC_V2 = True
 except ImportError:
     # Pydantic v1 compatibility
     from pydantic.json import ENCODERS_BY_TYPE
+
     PydanticUndefined = ...
     PYDANTIC_V2 = False
 

aredis_om/model/migrations/__init__.py

@@ -10,25 +10,24 @@
 from .data import BaseMigration, DataMigrationError, DataMigrator
 from .schema import (
     BaseSchemaMigration,
+    MigrationAction,
+    MigrationError,
+    Migrator,
     SchemaMigrationError,
     SchemaMigrator,
-    Migrator,
-    MigrationError,
-    MigrationAction
 )
 
+
 # Maintain backward compatibility by exposing the same API
 __all__ = [
     # Data migration classes
     "BaseMigration",
     "DataMigrationError",
     "DataMigrator",
-
     # Schema migration classes
     "BaseSchemaMigration",
     "SchemaMigrationError",
     "SchemaMigrator",
-
     # Legacy classes (for backward compatibility)
     "Migrator",
     "MigrationError",

aredis_om/model/migrations/data/__init__.py

@@ -8,4 +8,5 @@
 from .base import BaseMigration, DataMigrationError
 from .migrator import DataMigrator
 
+
 __all__ = ["BaseMigration", "DataMigrationError", "DataMigrator"]

aredis_om/model/migrations/data/base.py

@@ -9,6 +9,7 @@
 import time
 from typing import Any, Dict, List
 
+
 try:
     import psutil
 except ImportError:
@@ -19,6 +20,7 @@
 
 class DataMigrationError(Exception):
     """Exception raised when data migration operations fail."""
+
     pass
 
 

aredis_om/model/migrations/data/builtin/__init__.py

@@ -5,6 +5,11 @@
 common data transformation scenarios.
 """
 
-from .datetime_migration import DatetimeFieldMigration, DatetimeFieldDetector, ConversionFailureMode
+from .datetime_migration import (
+    ConversionFailureMode,
+    DatetimeFieldDetector,
+    DatetimeFieldMigration,
+)
+
 
 __all__ = ["DatetimeFieldMigration", "DatetimeFieldDetector", "ConversionFailureMode"]

aredis_om/model/migrations/data/builtin/datetime_migration.py

@@ -22,6 +22,7 @@
 
 class SchemaMismatchError(Exception):
     """Raised when deployed code expects different field types than what's in Redis."""
+
     pass
 
 
@@ -48,7 +49,9 @@ async def check_for_schema_mismatches(self, models: List[Any]) -> Dict[str, Any]
         for model in models:
             try:
                 # Get the current index schema from Redis
-                index_name = f"{model._meta.global_key_prefix}:{model._meta.model_key_prefix}"
+                index_name = (
+                    f"{model._meta.global_key_prefix}:{model._meta.model_key_prefix}"
+                )
 
                 try:
                     # Try to get index info
@@ -62,26 +65,31 @@ async def check_for_schema_mismatches(self, models: List[Any]) -> Dict[str, Any]
                 datetime_fields = self._get_datetime_fields(model)
 
                 for field_name, field_info in datetime_fields.items():
-                    redis_field_type = current_schema.get(field_name, {}).get('type')
-
-                    if redis_field_type == 'TAG' and field_info.get('expected_type') == 'NUMERIC':
-                        mismatches.append({
-                            'model': model.__name__,
-                            'field': field_name,
-                            'current_type': 'TAG',
-                            'expected_type': 'NUMERIC',
-                            'index_name': index_name
-                        })
+                    redis_field_type = current_schema.get(field_name, {}).get("type")
+
+                    if (
+                        redis_field_type == "TAG"
+                        and field_info.get("expected_type") == "NUMERIC"
+                    ):
+                        mismatches.append(
+                            {
+                                "model": model.__name__,
+                                "field": field_name,
+                                "current_type": "TAG",
+                                "expected_type": "NUMERIC",
+                                "index_name": index_name,
+                            }
+                        )
 
             except Exception as e:
                 log.warning(f"Could not check schema for model {model.__name__}: {e}")
                 continue
 
         return {
-            'has_mismatches': len(mismatches) > 0,
-            'mismatches': mismatches,
-            'total_affected_models': len(set(m['model'] for m in mismatches)),
-            'recommendation': self._get_recommendation(mismatches)
+            "has_mismatches": len(mismatches) > 0,
+            "mismatches": mismatches,
+            "total_affected_models": len(set(m["model"] for m in mismatches)),
+            "recommendation": self._get_recommendation(mismatches),
         }
 
     def _parse_index_schema(self, index_info: List) -> Dict[str, Dict[str, Any]]:
@@ -92,22 +100,27 @@ def _parse_index_schema(self, index_info: List) -> Dict[str, Dict[str, Any]]:
         info_dict = {}
         for i in range(0, len(index_info), 2):
             if i + 1 < len(index_info):
-                key = index_info[i].decode() if isinstance(index_info[i], bytes) else str(index_info[i])
+                key = (
+                    index_info[i].decode()
+                    if isinstance(index_info[i], bytes)
+                    else str(index_info[i])
+                )
                 value = index_info[i + 1]
                 info_dict[key] = value
 
         # Extract attributes (field definitions)
-        attributes = info_dict.get('attributes', [])
+        attributes = info_dict.get("attributes", [])
 
         for attr in attributes:
             if isinstance(attr, list) and len(attr) >= 4:
-                field_name = attr[0].decode() if isinstance(attr[0], bytes) else str(attr[0])
-                field_type = attr[2].decode() if isinstance(attr[2], bytes) else str(attr[2])
+                field_name = (
+                    attr[0].decode() if isinstance(attr[0], bytes) else str(attr[0])
+                )
+                field_type = (
+                    attr[2].decode() if isinstance(attr[2], bytes) else str(attr[2])
+                )
 
-                schema[field_name] = {
-                    'type': field_type,
-                    'raw_attr': attr
-                }
+                schema[field_name] = {"type": field_type, "raw_attr": attr}
 
         return schema
 
@@ -117,20 +130,20 @@ def _get_datetime_fields(self, model) -> Dict[str, Dict[str, Any]]:
 
         try:
             # Get model fields in a compatible way
-            if hasattr(model, '_get_model_fields'):
+            if hasattr(model, "_get_model_fields"):
                 model_fields = model._get_model_fields()
-            elif hasattr(model, 'model_fields'):
+            elif hasattr(model, "model_fields"):
                 model_fields = model.model_fields
             else:
-                model_fields = getattr(model, '__fields__', {})
+                model_fields = getattr(model, "__fields__", {})
 
             for field_name, field_info in model_fields.items():
                 # Check if this is a datetime field
-                field_type = getattr(field_info, 'annotation', None)
+                field_type = getattr(field_info, "annotation", None)
                 if field_type in (datetime.datetime, datetime.date):
                     datetime_fields[field_name] = {
-                        'expected_type': 'NUMERIC',  # New code expects NUMERIC
-                        'field_info': field_info
+                        "expected_type": "NUMERIC",  # New code expects NUMERIC
+                        "field_info": field_info,
                     }
 
         except Exception as e:

aredis_om/model/migrations/data/migrator.py

@@ -10,9 +10,9 @@
 import importlib.util
 import os
 import time
-from datetime import datetime, date
+from datetime import date, datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Callable
+from typing import Any, Callable, Dict, List, Optional, Set
 
 import redis
 
@@ -297,7 +297,7 @@ async def run_migrations_with_monitoring(
         dry_run: bool = False,
         limit: Optional[int] = None,
         verbose: bool = False,
-        progress_callback: Optional[Callable] = None  # type: ignore,
+        progress_callback: Optional[Callable] = None,  # type: ignore,
     ) -> Dict[str, Any]:
         """
         Run pending migrations with enhanced performance monitoring.

aredis_om/model/migrations/schema/__init__.py

@@ -6,14 +6,15 @@
 """
 
 from .base import BaseSchemaMigration, SchemaMigrationError
+from .legacy_migrator import MigrationAction, MigrationError, Migrator
 from .migrator import SchemaMigrator
-from .legacy_migrator import Migrator, MigrationError, MigrationAction
+
 
 __all__ = [
     "BaseSchemaMigration",
     "SchemaMigrationError",
     "SchemaMigrator",
     "Migrator",
     "MigrationError",
-    "MigrationAction"
+    "MigrationAction",
 ]

aredis_om/model/migrations/schema/base.py

@@ -12,6 +12,7 @@
 
 class SchemaMigrationError(Exception):
     """Exception raised when schema migration operations fail."""
+
     pass