Merge branch 'main' into dependabot/github_actions/codecov/codecov-action-5

Author: bsbodden

.github/workflows/ci.yml

@@ -76,7 +76,7 @@ jobs:
     strategy:
       matrix:
         os: [ ubuntu-latest ]
-        pyver: [ "3.9", "3.10", "3.11", "3.12", "pypy-3.9", "pypy-3.10" ]
+        pyver: [ "3.9", "3.10", "3.11", "3.12", "3.13", "pypy-3.9", "pypy-3.10" ]
         redisstack: [ "latest" ]
       fail-fast: false
     services:

.gitignore

@@ -143,4 +143,9 @@ tests_sync/
 # spelling cruft
 *.dic
 
-.idea
+.idea
+
+# version files
+.tool-versions
+
+.vscode/

aredis_om/__init__.py

@@ -16,3 +16,4 @@
     RedisModelError,
     VectorFieldOptions,
 )
+from .model.types import Coordinates, GeoFilter

aredis_om/model/model.py

@@ -1,6 +1,5 @@
 import abc
 import dataclasses
-import decimal
 import json
 import logging
 import operator
@@ -41,10 +40,11 @@
 from .. import redis
 from ..checks import has_redis_json, has_redisearch
 from ..connections import get_redis_connection
-from ..util import ASYNC_MODE
+from ..util import ASYNC_MODE, has_numeric_inner_type, is_numeric_type
 from .encoders import jsonable_encoder
 from .render_tree import render_tree
 from .token_escaper import TokenEscaper
+from .types import Coordinates, CoordinateType, GeoFilter
 
 
 model_registry = {}
@@ -405,8 +405,6 @@ class RediSearchFieldTypes(Enum):
     GEO = "GEO"
 
 
-# TODO: How to handle Geo fields?
-NUMERIC_TYPES = (float, int, decimal.Decimal)
 DEFAULT_PAGE_SIZE = 1000
 
 
@@ -536,8 +534,12 @@ def validate_sort_fields(self, sort_fields: List[str]):
     def resolve_field_type(field: "FieldInfo", op: Operators) -> RediSearchFieldTypes:
         field_info: Union[FieldInfo, PydanticFieldInfo] = field
 
+        typ = get_outer_type(field_info)
+
         if getattr(field_info, "primary_key", None) is True:
             return RediSearchFieldTypes.TAG
+        elif typ in [CoordinateType, Coordinates]:
+            return RediSearchFieldTypes.GEO
         elif op is Operators.LIKE:
             fts = getattr(field_info, "full_text_search", None)
             if fts is not True:  # Could be PydanticUndefined
@@ -553,7 +555,6 @@ def resolve_field_type(field: "FieldInfo", op: Operators) -> RediSearchFieldType
         if not isinstance(field_type, type):
             field_type = field_type.__origin__
 
-        # TODO: GEO fields
         container_type = get_origin(field_type)
 
         if is_supported_container_type(container_type):
@@ -578,7 +579,7 @@ def resolve_field_type(field: "FieldInfo", op: Operators) -> RediSearchFieldType
             )
         elif field_type is bool:
             return RediSearchFieldTypes.TAG
-        elif any(issubclass(field_type, t) for t in NUMERIC_TYPES):
+        elif is_numeric_type(field_type):
             # Index numeric Python types as NUMERIC fields, so we can support
             # range queries.
             return RediSearchFieldTypes.NUMERIC
@@ -727,6 +728,15 @@ def resolve_value(
                     field_name=field_name, expanded_value=expanded_value
                 )
 
+        elif field_type is RediSearchFieldTypes.GEO:
+            if not isinstance(value, GeoFilter):
+                raise QuerySyntaxError(
+                    "You can only use a GeoFilter object with a GEO field."
+                )
+
+            if op is Operators.EQ:
+                result += f"@{field_name}:[{value}]"
+
         return result
 
     def resolve_redisearch_pagination(self):
@@ -1378,12 +1388,14 @@ def outer_type_or_annotation(field: FieldInfo):
 def should_index_field(field_info: Union[FieldInfo, PydanticFieldInfo]) -> bool:
     # for vector, full text search, and sortable fields, we always have to index
     # We could require the user to set index=True, but that would be a breaking change
-    index = getattr(field_info, "index", None) is True
+    _index = getattr(field_info, "index", None)
+
+    index = _index is True
     vector_options = getattr(field_info, "vector_options", None) is not None
     full_text_search = getattr(field_info, "full_text_search", None) is True
     sortable = getattr(field_info, "sortable", None) is True
 
-    if index is False and any([vector_options, full_text_search, sortable]):
+    if _index is False and any([vector_options, full_text_search, sortable]):
         log.warning(
             "Field is marked as index=False, but it is a vector, full text search, or sortable field. "
             "This will be ignored and the field will be indexed.",
@@ -1803,7 +1815,9 @@ def schema_for_type(cls, name, typ: Any, field_info: PydanticFieldInfo):
             schema = cls.schema_for_type(name, embedded_cls, field_info)
         elif typ is bool:
             schema = f"{name} TAG"
-        elif any(issubclass(typ, t) for t in NUMERIC_TYPES):
+        elif typ in [CoordinateType, Coordinates]:
+            schema = f"{name} GEO"
+        elif is_numeric_type(typ):
             vector_options: Optional[VectorFieldOptions] = getattr(
                 field_info, "vector_options", None
             )
@@ -1965,7 +1979,7 @@ def schema_for_type(
         json_path: str,
         name: str,
         name_prefix: str,
-        typ: Union[type[RedisModel], Any],
+        typ: Union[Type[RedisModel], Any],
         field_info: PydanticFieldInfo,
         parent_type: Optional[Any] = None,
     ) -> str:
@@ -2002,9 +2016,7 @@ def schema_for_type(
             field_info, "vector_options", None
         )
         try:
-            is_vector = vector_options and any(
-                issubclass(get_args(typ)[0], t) for t in NUMERIC_TYPES
-            )
+            is_vector = vector_options and has_numeric_inner_type(typ)
         except IndexError:
             raise RedisModelError(
                 f"Vector field '{name}' must be annotated as a container type"
@@ -2102,9 +2114,12 @@ def schema_for_type(
             # a proper type, we can pull the type information from the origin of the first argument.
             if not isinstance(typ, type):
                 type_args = typing_get_args(field_info.annotation)
-                typ = type_args[0].__origin__
+                typ = (
+                    getattr(type_args[0], "__origin__", type_args[0])
+                    if type_args
+                    else typ
+                )
 
-            # TODO: GEO field
             if is_vector and vector_options:
                 schema = f"{path} AS {index_field_name} {vector_options.schema}"
             elif parent_is_container_type or parent_is_model_in_container:
@@ -2125,7 +2140,9 @@ def schema_for_type(
                     schema += " CASESENSITIVE"
             elif typ is bool:
                 schema = f"{path} AS {index_field_name} TAG"
-            elif any(issubclass(typ, t) for t in NUMERIC_TYPES):
+            elif typ in [CoordinateType, Coordinates]:
+                schema = f"{path} AS {index_field_name} GEO"
+            elif is_numeric_type(typ):
                 schema = f"{path} AS {index_field_name} NUMERIC"
             elif issubclass(typ, str):
                 if full_text_search is True:

aredis_om/model/types.py

@@ -0,0 +1,116 @@
+from typing import Annotated, Any, Literal, Tuple, Union
+
+from pydantic import BeforeValidator, PlainSerializer
+from pydantic_extra_types.coordinate import Coordinate
+
+
+RadiusUnit = Literal["m", "km", "mi", "ft"]
+
+
+class GeoFilter:
+    """
+    A geographic filter for searching within a radius of a coordinate point.
+
+    This filter is used with GEO fields to find models within a specified
+    distance from a given location.
+
+    Args:
+        longitude: The longitude of the center point (-180 to 180)
+        latitude: The latitude of the center point (-90 to 90)
+        radius: The search radius (must be positive)
+        unit: The unit of measurement ('m', 'km', 'mi', or 'ft')
+
+    Example:
+        >>> # Find all locations within 10 miles of Portland, OR
+        >>> filter = GeoFilter(
+        ...     longitude=-122.6765,
+        ...     latitude=45.5231,
+        ...     radius=10,
+        ...     unit="mi"
+        ... )
+        >>> results = await Location.find(
+        ...     Location.coordinates == filter
+        ... ).all()
+    """
+
+    def __init__(
+        self, longitude: float, latitude: float, radius: float, unit: RadiusUnit
+    ):
+        # Validate coordinates
+        if not -180 <= longitude <= 180:
+            raise ValueError(f"Longitude must be between -180 and 180, got {longitude}")
+        if not -90 <= latitude <= 90:
+            raise ValueError(f"Latitude must be between -90 and 90, got {latitude}")
+        if radius <= 0:
+            raise ValueError(f"Radius must be positive, got {radius}")
+
+        self.longitude = longitude
+        self.latitude = latitude
+        self.radius = radius
+        self.unit = unit
+
+    def __str__(self) -> str:
+        return f"{self.longitude} {self.latitude} {self.radius} {self.unit}"
+
+    @classmethod
+    def from_coordinates(
+        cls, coords: Coordinate, radius: float, unit: RadiusUnit
+    ) -> "GeoFilter":
+        """
+        Create a GeoFilter from a Coordinates object.
+
+        Args:
+            coords: A Coordinate object with latitude and longitude
+            radius: The search radius
+            unit: The unit of measurement
+
+        Returns:
+            A new GeoFilter instance
+        """
+        return cls(coords.longitude, coords.latitude, radius, unit)
+
+
+CoordinateType = Coordinate
+
+
+def parse_redis(v: Any) -> Union[Tuple[str, str], Any]:
+    """
+    Transform Redis coordinate format to Pydantic coordinate format.
+
+    The pydantic coordinate type expects a string in the format 'latitude,longitude'.
+    Redis stores coordinates in the format 'longitude,latitude'.
+
+    This validator transforms the input from Redis into the expected format for pydantic.
+
+    Args:
+        v: The value from Redis (typically a string like "longitude,latitude")
+
+    Returns:
+        A tuple of (latitude, longitude) strings if input is a coordinate string,
+        otherwise returns the input unchanged.
+
+    Raises:
+        ValueError: If the coordinate string format is invalid
+    """
+    if isinstance(v, str):
+        parts = v.split(",")
+
+        if len(parts) != 2:
+            raise ValueError(
+                f"Invalid coordinate format. Expected 'longitude,latitude' but got: {v}"
+            )
+
+        return (parts[1], parts[0])  # Swap to (latitude, longitude)
+
+    return v
+
+
+Coordinates = Annotated[
+    CoordinateType,
+    PlainSerializer(
+        lambda v: f"{v.longitude},{v.latitude}",
+        return_type=str,
+        when_used="unless-none",
+    ),
+    BeforeValidator(parse_redis),
+]

aredis_om/util.py

@@ -1,4 +1,6 @@
+import decimal
 import inspect
+from typing import Any, Type, get_args
 
 
 def is_async_mode() -> bool:
@@ -10,3 +12,27 @@ async def f() -> None:
 
 
 ASYNC_MODE = is_async_mode()
+
+NUMERIC_TYPES = (float, int, decimal.Decimal)
+
+
+def is_numeric_type(type_: Type[Any]) -> bool:
+    try:
+        return issubclass(type_, NUMERIC_TYPES)
+    except TypeError:
+        return False
+
+
+def has_numeric_inner_type(type_: Type[Any]) -> bool:
+    """
+    Check if the type has a numeric inner type.
+    """
+    args = get_args(type_)
+
+    if not args:
+        return False
+
+    try:
+        return issubclass(args[0], NUMERIC_TYPES)
+    except TypeError:
+        return False

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "redis-om"
-version = "1.0.0-beta"
+version = "1.0.3-beta"
 description = "Object mappings, and more, for Redis."
 authors = ["Redis OSS <[email protected]>"]
 maintainers = ["Redis OSS <[email protected]>"]
@@ -22,6 +22,7 @@ classifiers = [
     'Programming Language :: Python :: 3.10',
     'Programming Language :: Python :: 3.11',
     'Programming Language :: Python :: 3.12',
+    'Programming Language :: Python :: 3.13',
     'Programming Language :: Python',
 ]
 include=[
@@ -36,7 +37,7 @@ include=[
 
 [tool.poetry.dependencies]
 python = ">=3.8,<4.0"
-redis = ">=3.5.3,<6.0.0"
+redis = ">=3.5.3,<7.0.0"
 pydantic = ">=2.0.0,<3.0.0"
 click = "^8.0.1"
 types-redis = ">=3.5.9,<5.0.0"
@@ -45,8 +46,9 @@ typing-extensions = "^4.4.0"
 hiredis = ">=2.2.3,<4.0.0"
 more-itertools = ">=8.14,<11.0"
 setuptools = ">=70.0"
+pydantic-extra-types = "^2.10.5"
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev.dependencies]
 mypy = "^1.9.0"
 pytest = "^8.0.2"
 ipdb = "^0.13.9"