merging

Author: slorello89

Makefile

@@ -53,7 +53,7 @@ sync: $(INSTALL_STAMP)
 lint: $(INSTALL_STAMP) dist
 	$(POETRY) run isort --profile=black --lines-after-imports=2 ./tests/ $(NAME) $(SYNC_NAME)
 	$(POETRY) run black ./tests/ $(NAME)
-	$(POETRY) run flake8 --ignore=W503,E501,F401,E731 ./tests/ $(NAME) $(SYNC_NAME)
+	$(POETRY) run flake8 --ignore=W503,E501,F401,E731,E712 ./tests/ $(NAME) $(SYNC_NAME)
 	$(POETRY) run mypy ./tests/ $(NAME) $(SYNC_NAME) --ignore-missing-imports --exclude migrate.py --exclude _compat\.py$
 	$(POETRY) run bandit -r $(NAME) $(SYNC_NAME) -s B608
 

aredis_om/model/model.py

@@ -83,6 +83,8 @@ def get_outer_type(field):
         field.annotation
     ):
         return field.annotation
+    elif not hasattr(field.annotation, "__args__"):
+        return None
     else:
         return field.annotation.__args__[0]
 
@@ -116,6 +118,8 @@ class Operators(Enum):
     STARTSWITH = 14
     ENDSWITH = 15
     CONTAINS = 16
+    TRUE = 17
+    FALSE = 18
 
     def __str__(self):
         return str(self.name)
@@ -582,6 +586,8 @@ def resolve_field_type(
                 "Only lists and tuples are supported for multi-value fields. "
                 f"Docs: {ERRORS_URL}#E4"
             )
+        elif field_type is bool:
+            return RediSearchFieldTypes.TAG
         elif any(issubclass(field_type, t) for t in NUMERIC_TYPES):
             # Index numeric Python types as NUMERIC fields, so we can support
             # range queries.
@@ -676,7 +682,11 @@ def resolve_value(
                         separator_char,
                     )
                     return ""
-                if isinstance(value, int):
+                if isinstance(value, bool):
+                    result = "@{field_name}:{{{value}}}".format(
+                        field_name=field_name, value=value
+                    )
+                elif isinstance(value, int):
                     # This if will hit only if the field is a primary key of type int
                     result = f"@{field_name}:[{value} {value}]"
                 elif separator_char in value:
@@ -1628,6 +1638,11 @@ def check(self):
             *_, validation_error = validate_model(self.__class__, self.__dict__)
             if validation_error:
                 raise validation_error
+        else:
+            from pydantic import TypeAdapter
+
+            adapter = TypeAdapter(self.__class__)
+            adapter.validate_python(self.__dict__)
 
 
 class HashModel(RedisModel, abc.ABC):
@@ -1817,6 +1832,8 @@ def schema_for_type(cls, name, typ: Any, field_info: PydanticFieldInfo):
                 return ""
             embedded_cls = embedded_cls[0]
             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):
             vector_options: Optional[VectorFieldOptions] = getattr(
                 field_info, "vector_options", None
@@ -1946,6 +1963,9 @@ def schema_for_fields(cls):
 
         for name, field in fields.items():
             _type = get_outer_type(field)
+            if _type is None:
+                continue
+
             if (
                 not isinstance(field, FieldInfo)
                 and hasattr(field, "metadata")
@@ -2124,6 +2144,8 @@ def schema_for_type(
                     raise sortable_tag_error
                 if case_sensitive is True:
                     schema += " CASESENSITIVE"
+            elif typ is bool:
+                schema = f"{path} AS {index_field_name} TAG"
             elif any(issubclass(typ, t) for t in NUMERIC_TYPES):
                 schema = f"{path} AS {index_field_name} NUMERIC"
             elif issubclass(typ, str):

docs/getting_started.md

@@ -702,6 +702,27 @@ Customer.find((Customer.last_name == "Brookins") | (
 ) & (Customer.last_name == "Smith")).all()
 ```
 
+### Saving and querying Boolean values
+
+For historical reasons, saving and querying Boolean values is not supported in `HashModels`, however in JSON models,
+you may store and query Boolean values using the `==` syntax:
+
+```python
+from redis_om import (
+    Field,
+    JsonModel,
+    Migrator
+)
+
+class Demo(JsonModel):
+    b: bool = Field(index=True)
+
+Migrator().run()
+d = Demo(b=True)
+d.save()
+res = Demo.find(Demo.b == True)
+```
+
 ## Calling Other Redis Commands
 
 Sometimes you'll need to run a Redis command directly.  Redis OM supports this through the `db` method on your model's class.  This returns a connected Redis client instance which exposes a function named for each Redis command.  For example, let's perform some basic set operations:

tests/test_hash_model.py

@@ -896,3 +896,21 @@ class ModelWithStringDefault(HashModel):
     await b.save()
     res = await ModelWithStringDefault.find(ModelWithStringDefault.pk == b.pk).first()
     assert res.test == "None"
+
+
+async def test_update_validation():
+    class TestUpdate(HashModel):
+        name: str
+        age: int
+
+    await Migrator().run()
+    t = TestUpdate(name="steve", age=34)
+    await t.save()
+    update_dict = dict()
+    update_dict["age"] = "cat"
+
+    with pytest.raises(ValidationError):
+        await t.update(**update_dict)
+
+    rematerialized = await TestUpdate.find(TestUpdate.pk == t.pk).first()
+    assert rematerialized.age == 34

tests/test_json_model.py

@@ -992,3 +992,80 @@ class ModelWithStringDefault(JsonModel):
     await b.save()
     res = await ModelWithStringDefault.find(ModelWithStringDefault.pk == b.pk).first()
     assert res.test == "None"
+
+
+async def test_update_validation():
+
+    class Embedded(EmbeddedJsonModel):
+        price: float
+        name: str = Field(index=True)
+
+    class TestUpdatesClass(JsonModel):
+        name: str
+        age: int
+        embedded: Embedded
+
+    await Migrator().run()
+    embedded = Embedded(price=3.14, name="foo")
+    t = TestUpdatesClass(name="str", age=42, embedded=embedded)
+    await t.save()
+
+    update_dict = dict()
+    update_dict["age"] = "foo"
+    with pytest.raises(ValidationError):
+        await t.update(**update_dict)
+
+    t.age = 42
+    update_dict.clear()
+    update_dict["embedded"] = "hello"
+    with pytest.raises(ValidationError):
+        await t.update(**update_dict)
+
+    rematerialized = await TestUpdatesClass.find(TestUpdatesClass.pk == t.pk).first()
+    assert rematerialized.age == 42
+
+
+async def test_model_with_dict():
+    class EmbeddedJsonModelWithDict(EmbeddedJsonModel):
+        dict: Dict
+
+    class ModelWithDict(JsonModel):
+        embedded_model: EmbeddedJsonModelWithDict
+        info: Dict
+
+    await Migrator().run()
+    d = dict()
+    inner_dict = dict()
+    d["foo"] = "bar"
+    inner_dict["bar"] = "foo"
+    embedded_model = EmbeddedJsonModelWithDict(dict=inner_dict)
+    item = ModelWithDict(info=d, embedded_model=embedded_model)
+    await item.save()
+
+    rematerialized = await ModelWithDict.find(ModelWithDict.pk == item.pk).first()
+    assert rematerialized.pk == item.pk
+    assert rematerialized.info["foo"] == "bar"
+    assert rematerialized.embedded_model.dict["bar"] == "foo"
+
+
+@py_test_mark_asyncio
+async def test_boolean():
+    class Example(JsonModel):
+        b: bool = Field(index=True)
+        d: datetime.date = Field(index=True)
+        name: str = Field(index=True)
+
+    await Migrator().run()
+
+    ex = Example(b=True, name="steve", d=datetime.date.today())
+    exFalse = Example(b=False, name="foo", d=datetime.date.today())
+    await ex.save()
+    await exFalse.save()
+    res = await Example.find(Example.b == True).first()
+    assert res.name == "steve"
+
+    res = await Example.find(Example.b == False).first()
+    assert res.name == "foo"
+
+    res = await Example.find(Example.d == ex.d and Example.b == True).first()
+    assert res.name == ex.name