Merge pull request #15 from LeonardoLBraga/feature/in-operator

✨ Feature/in operator

Author: YoanSallami

synalinks/src/backend/common/json_data_model.py

@@ -308,6 +308,19 @@ def __rxor__(self, other):
             ops.Xor().call(other, self),
         )
 
+    def __contains__(self, other):
+        """Check if the schema of `other` is contained in this one.
+
+        Args:
+            other (SymbolicDataModel | DataModel): The other data model to compare with.
+
+        Returns:
+            (bool): True if all properties of `other` are present in this one.
+        """
+        from synalinks.src.backend.common.json_schema_utils import contains_schema
+
+        return contains_schema(self.get_schema(), other.get_schema())
+
     def factorize(self):
         """Factorizes the data model.
 

synalinks/src/backend/common/json_data_model_test.py

@@ -286,3 +286,21 @@ class DocumentGraph(KnowledgeGraph):
         obj = relations[0].get_nested_entity("obj")
         self.assertTrue(subj.get_schema() == Document.get_schema())
         self.assertTrue(obj.get_schema() == Document.get_schema())
+
+    def test_contains_json_data_model(self):
+        class Foo(DataModel):
+            foo: str
+
+        class FooBar(DataModel):
+            foo: str
+            bar: str
+
+        class Bar(DataModel):
+            bar: str
+
+        foo_json = JsonDataModel(data_model=Foo(foo="a"))
+        foobar_json = JsonDataModel(data_model=FooBar(foo="a", bar="b"))
+        bar_json = JsonDataModel(data_model=Bar(bar="c"))
+
+        self.assertTrue(foo_json in foobar_json)
+        self.assertFalse(bar_json in foo_json)

synalinks/src/backend/common/symbolic_data_model.py

@@ -300,6 +300,19 @@ def __rxor__(self, other):
             ops.Xor().symbolic_call(other, self)
         )
 
+    def __contains__(self, other):
+        """Check if the schema of `other` is contained in this one.
+
+        Args:
+            other (SymbolicDataModel | DataModel): The other data model to compare with.
+
+        Returns:
+            (bool): True if all properties of `other` are present in this one.
+        """
+        from synalinks.src.backend.common.json_schema_utils import contains_schema
+
+        return contains_schema(self.get_schema(), other.get_schema())
+
     def factorize(self):
         """Factorizes the data model.
 

synalinks/src/backend/common/symbolic_data_model_test.py

@@ -45,3 +45,21 @@ class Query(DataModel):
             f"<SymbolicDataModel schema={standardize_schema(Query.get_schema())}",
             repr(x),
         )
+
+    def test_contains_symbolic_data_model(self):
+        class Foo(DataModel):
+            foo: str
+
+        class FooBar(DataModel):
+            foo: str
+            bar: str
+
+        class Bar(DataModel):
+            bar: str
+
+        foo_symbolic = SymbolicDataModel(data_model=Foo)
+        foobar_symbolic = SymbolicDataModel(data_model=FooBar)
+        bar_symbolic = SymbolicDataModel(data_model=Bar)
+
+        self.assertTrue(foo_symbolic in foobar_symbolic)
+        self.assertFalse(bar_symbolic in foo_symbolic)

synalinks/src/backend/common/variables.py

@@ -265,6 +265,19 @@ def get_schema(self):
         """
         return self._schema
 
+    def __contains__(self, other):
+        """Check if the schema of `other` is contained within the schema of this variable.
+
+        Args:
+            other (SymbolicDataModel | DataModel): The data model to compare against this variable's schema.
+
+        Returns:
+            bool: True if `other`'s schema is a subset of this variable's schema.
+        """
+        from synalinks.src.backend.common.json_schema_utils import contains_schema
+
+        return contains_schema(self.get_schema(), other.get_schema())
+
     @property
     def trainable(self):
         """Whether the variable is trainable."""

synalinks/src/backend/common/variables_test.py

@@ -93,3 +93,16 @@ class Instructions(DataModel):
             variable_from_dict.get_schema(),
             standardize_schema(Instructions.get_schema()),
         )
+
+    def test_contains_operator(self):
+        class Foo(DataModel):
+            foo: str = ""
+
+        class FooBar(DataModel):
+            foo: str = ""
+            bar: str = ""
+
+        variable = Variable(initializer={"foo": "value", "bar": "value2"}, data_model=FooBar)
+
+        self.assertTrue(Foo in variable)
+        self.assertFalse(FooBar in Foo)

synalinks/src/backend/pydantic/core.py

@@ -176,6 +176,19 @@ def __rxor__(cls, other):
             ops.Xor().symbolic_call(other, cls)
         )
 
+    def __contains__(cls, other):
+        """Check if the schema of `other` is contained in this one.
+
+        Args:
+            other (SymbolicDataModel | DataModel): The other data model to compare with.
+
+        Returns:
+            (bool): True if all properties of `other` are present in this one.
+        """
+        from synalinks.src.backend.common.json_schema_utils import contains_schema
+
+        return contains_schema(cls.get_schema(), other.get_schema())
+
     def factorize(cls):
         """Factorizes the data model.
 
@@ -549,6 +562,19 @@ def __rxor__(self, other):
                 ops.Xor()(other, self),
             )
 
+    def __contains__(cls, other):
+        """Check if the schema of `other` is contained in this one.
+
+        Args:
+            other (SymbolicDataModel | DataModel): The other data model to compare with.
+
+        Returns:
+            (bool): True if all properties of `other` are present in this one.
+        """
+        from synalinks.src.backend.common.json_schema_utils import contains_schema
+
+        return contains_schema(cls.get_schema(), other.get_schema())
+
     def get_config(self):
         return self.get_json()
 

synalinks/src/backend/pydantic/core_test.py

@@ -123,3 +123,17 @@ class Query(DataModel):
             query: str
 
         self.assertFalse(is_meta_class(Query(query="What is the French capital?")))
+
+    def test_contains_meta_class(self):
+        class Foo(DataModel):
+            foo: str
+
+        class FooBar(DataModel):
+            foo: str
+            bar: str
+
+        class Bar(DataModel):
+            bar: str
+
+        self.assertTrue(Foo in FooBar)
+        self.assertFalse(Bar in Foo)