support for JanusGraph 1.1.0; added text predicates; version bump of dependencies

pm-osc · pm-osc · commit d97d5aaa5b94 · 2024-11-20T22:41:54.000+01:00
Signed-off-by: pm-osc &lt;pm2.osc@gmail.com&gt;
diff --git a/README.md b/README.md
@@ -66,6 +66,7 @@ of JanusGraph-Python:
 | JanusGraph-Python | JanusGraph             |
 | ----------------- | ---------------------- |
 | 1.0.z             | 1.0.z                  |
+| 1.1.z             | 1.1.z                  |
 
 While it should also be possible to use JanusGraph-Python with other versions of
 JanusGraph than mentioned here, compatibility is not tested and some
diff --git a/janusgraph_python/process/traversal.py b/janusgraph_python/process/traversal.py
@@ -46,6 +46,16 @@ def text_contains(*args):
         """
         return _JanusGraphP("textContains", *args)
     
+    @staticmethod
+    def text_not_contains(*args):
+        """
+        Is true if no words inside the text string match the query string.
+
+        :param query: string, The query to search.
+        :return The text predicate.
+        """
+        return _JanusGraphP("textNotContains", *args)
+
     @staticmethod
     def text_contains_prefix(*args):
         """
@@ -56,6 +66,16 @@ def text_contains_prefix(*args):
         """
         return _JanusGraphP("textContainsPrefix", *args)
     
+    @staticmethod
+    def text_not_contains_prefix(*args):
+        """
+        Is true if no words inside the text string begin with the query string.
+
+        :param query: string, The query to search.
+        :return The text predicate.
+        """
+        return _JanusGraphP("textNotContainsPrefix", *args)
+
     @staticmethod
     def text_contains_regex(*args):
         """
@@ -66,6 +86,16 @@ def text_contains_regex(*args):
         """
         return _JanusGraphP("textContainsRegex", *args)
     
+    @staticmethod
+    def text_not_contains_regex(*args):
+        """
+        Is true if no words inside the text string match the given regular expression.
+
+        :param query: string, The query to search.
+        :return The text predicate.
+        """
+        return _JanusGraphP("textNotContainsRegex", *args)
+
     @staticmethod
     def text_contains_fuzzy(*args):
         """
@@ -77,6 +107,37 @@ def text_contains_fuzzy(*args):
         """
         return _JanusGraphP("textContainsFuzzy", *args)
     
+    @staticmethod
+    def text_not_contains_fuzzy(*args):
+        """
+        Is true if no words inside the text string are similar to the query string
+        (based on Levenshtein edit distance).
+
+        :param query: string, The query to search.
+        :return The text predicate.
+        """
+        return _JanusGraphP("textNotContainsFuzzy", *args)
+
+    @staticmethod
+    def text_contains_phrase(*args):
+        """
+        Is true if the text string does contain the sequence of words in the query string.
+
+        :param query: string, The query to search.
+        :return The text predicate.
+        """
+        return _JanusGraphP("textContainsPhrase", *args)
+
+    @staticmethod
+    def text_not_contains_phrase(*args):
+        """
+        Is true if the text string does not contain the sequence of words in the query string.
+
+        :param query: string, The query to search.
+        :return The text predicate.
+        """
+        return _JanusGraphP("textNotContainsPhrase", *args)
+
     @staticmethod
     def text_prefix(*args):
         """
@@ -87,6 +148,16 @@ def text_prefix(*args):
         """
         return _JanusGraphP("textPrefix", *args)
     
+    @staticmethod
+    def text_not_prefix(*args):
+        """
+        Is true if the string value does not start with the given query string.
+
+        :param query: string, The query to search.
+        :return The text predicate.
+        """
+        return _JanusGraphP("textNotPrefix", *args)
+
     @staticmethod
     def text_regex(*args):
         """
@@ -97,6 +168,16 @@ def text_regex(*args):
         """
         return _JanusGraphP("textRegex", *args)
 
+    @staticmethod
+    def text_not_regex(*args):
+        """
+        Is true if the string value does not match the given regular expression in its entirety.
+
+        :param query: string, The query to search.
+        :return The text predicate.
+        """
+        return _JanusGraphP("textNotRegex", *args)
+
     @staticmethod
     def text_fuzzy(*args):
         """
@@ -107,6 +188,16 @@ def text_fuzzy(*args):
         """
         return _JanusGraphP("textFuzzy", *args)
 
+    @staticmethod
+    def text_not_fuzzy(*args):
+        """
+        Is true if the string value is not similar to the given query string (based on Levenshtein edit distance).
+
+        :param query: string, The query to search.
+        :return The text predicate.
+        """
+        return _JanusGraphP("textNotFuzzy", *args)
+
 class RelationIdentifier(object):
     _TO_STRING_DELIMITER = '-'
 
diff --git a/requirements.txt b/requirements.txt
@@ -1,6 +1 @@
-aiohttp==3.10.10
-
-# on Python 3.11 and 3.12 this is not installed automatically as dependency of aiohttp
-async-timeout==4.0.3
-
-gremlinpython==3.7.2
+gremlinpython==3.7.3
diff --git a/setup.py b/setup.py
@@ -18,7 +18,7 @@ def read_requirements(path):
 
 setup(
     name='janusgraphpython',
-    version='1.0.0',
+    version='1.1.0',
     description='JanusGraph-Python extends Apache TinkerPop™''s Gremlin-Python with support for JanusGraph-specific types.',
     long_description=(this_directory/'README.md').read_text(),
     long_description_content_type='text/markdown',
diff --git a/tests/integration/Text_test.py b/tests/integration/Text_test.py
@@ -30,6 +30,17 @@ def test_text_contains_given_search_text(self, search_text, expected_count):
         count = self.g.E().has('reason', Text.text_contains(search_text)).count().next()
         assert count == expected_count
 
+    @mark.parametrize(
+        'search_text,expected_count',
+        [
+            param('loves', 1),
+            param('shouldNotBeFound', 3),
+        ]
+    )
+    def test_text_not_contains_given_search_text(self, search_text, expected_count):
+        count = self.g.E().has('reason', Text.text_not_contains(search_text)).count().next()
+        assert count == expected_count
+
     @mark.parametrize(
         'search_text,expected_count',
         [
@@ -42,6 +53,18 @@ def test_text_contains_prefix_given_search_text(self, search_text, expected_coun
         count = self.g.E().has('reason', Text.text_contains_prefix(search_text)).count().next()
         assert count == expected_count
 
+    @mark.parametrize(
+        'search_text,expected_count',
+        [
+            param('wave', 2),
+            param('f', 1),
+            param('shouldNotBeFound', 3),
+        ]
+    )
+    def test_text_contains_not_prefix_given_search_text(self, search_text, expected_count):
+        count = self.g.E().has('reason', Text.text_not_contains_prefix(search_text)).count().next()
+        assert count == expected_count
+
     @mark.parametrize(
         'search_text,expected_count',
         [
@@ -54,6 +77,18 @@ def test_text_contains_regex_given_search_text(self, search_text, expected_count
         count = self.g.E().has('reason', Text.text_contains_regex(search_text)).count().next()
         assert count == expected_count
 
+    @mark.parametrize(
+        'search_text,expected_count',
+        [
+            param('.*ave.*', 2),
+            param('f.{3,4}', 1),
+            param('shouldNotBeFound', 3),
+        ]
+    )
+    def test_text_not_contains_regex_given_search_text(self, search_text, expected_count):
+        count = self.g.E().has('reason', Text.text_not_contains_regex(search_text)).count().next()
+        assert count == expected_count
+
     @mark.parametrize(
         'search_text,expected_count',
         [
@@ -65,6 +100,43 @@ def test_text_contains_fuzzy_given_search_text(self, search_text, expected_count
         count = self.g.E().has('reason', Text.text_contains_fuzzy(search_text)).count().next()
         assert count == expected_count
 
+    @mark.parametrize(
+        'search_text,expected_count',
+        [
+            param('waxes', 2),
+            param('shouldNotBeFound', 3),
+        ]
+    )
+    def test_text_not_contains_fuzzy_given_search_text(self, search_text, expected_count):
+        count = self.g.E().has('reason', Text.text_not_contains_fuzzy(search_text)).count().next()
+        assert count == expected_count
+
+    @mark.parametrize(
+        'search_text,expected_count',
+        [
+            param('fresh breezes', 1),
+            param('no fear', 1),
+            param('fear of', 1),
+            param('should not be found', 0),
+        ]
+    )
+    def test_text_contains_phrase_given_search_text(self, search_text, expected_count):
+        count = self.g.E().has('reason', Text.text_contains_phrase(search_text)).count().next()
+        assert count == expected_count
+
+    @mark.parametrize(
+        'search_text,expected_count',
+        [
+            param('fresh breezes', 2),
+            param('no fear', 2),
+            param('fear of', 2),
+            param('should not be found', 3),
+        ]
+    )
+    def test_text_not_contains_phrase_given_search_text(self, search_text, expected_count):
+        count = self.g.E().has('reason', Text.text_not_contains_phrase(search_text)).count().next()
+        assert count == expected_count
+
     @mark.parametrize(
         'search_text,expected_count',
         [
@@ -77,6 +149,18 @@ def test_text_prefix_given_search_text(self, search_text, expected_count):
         count = self.g.V().has('name', Text.text_prefix(search_text)).count().next()
         assert count == expected_count
 
+    @mark.parametrize(
+        'search_text,expected_count',
+        [
+            param('herc', 11),
+            param('s', 9),
+            param('shouldNotBeFound', 12),
+        ]
+    )
+    def test_text_not_prefix_given_search_text(self, search_text, expected_count):
+        count = self.g.V().has('name', Text.text_not_prefix(search_text)).count().next()
+        assert count == expected_count
+
     @mark.parametrize(
         'search_text,expected_count',
         [
@@ -89,6 +173,18 @@ def test_text_regex_given_search_text(self, search_text, expected_count):
         count = self.g.V().has('name', Text.text_regex(search_text)).count().next()
         assert count == expected_count
 
+    @mark.parametrize(
+        'search_text,expected_count',
+        [
+            param('.*rcule.*', 11),
+            param('s.{2}', 10),
+            param('shouldNotBeFound', 12),
+        ]
+    )
+    def test_text_not_regex_given_search_text(self, search_text, expected_count):
+        count = self.g.V().has('name', Text.text_not_regex(search_text)).count().next()
+        assert count == expected_count
+
     @mark.parametrize(
         'search_text,expected_count',
         [
@@ -100,4 +196,15 @@ def test_text_regex_given_search_text(self, search_text, expected_count):
     def test_text_fuzzy_given_search_text(self, search_text, expected_count):
         count = self.g.V().has('name', Text.text_fuzzy(search_text)).count().next()
         assert count == expected_count
-        
+
+    @mark.parametrize(
+        'search_text,expected_count',
+        [
+            param('herculex', 11),
+            param('ska', 10),
+            param('shouldNotBeFound', 12),
+        ]
+    )
+    def test_text_not_fuzzy_given_search_text(self, search_text, expected_count):
+        count = self.g.V().has('name', Text.text_not_fuzzy(search_text)).count().next()
+        assert count == expected_count
diff --git a/tests/integration/config.ini b/tests/integration/config.ini
@@ -1,2 +1,2 @@
 [docker]
-image = janusgraph/janusgraph:1.0.0
+image = janusgraph/janusgraph:1.1.0
diff --git a/tests/unit/process/test_traversal.py b/tests/unit/process/test_traversal.py
@@ -219,12 +219,21 @@ class TestText(object):
         'predicate,expected',
         [
             param(Text.text_contains('John'), 'textContains(John)', id='text_contains'),
+            param(Text.text_not_contains('John'), 'textNotContains(John)', id='text_not_contains'),
             param(Text.text_contains_prefix('John'), 'textContainsPrefix(John)', id='text_contains_prefix'),
+            param(Text.text_not_contains_prefix('John'), 'textNotContainsPrefix(John)', id='text_not_contains_prefix'),
             param(Text.text_contains_fuzzy('Juhn'), 'textContainsFuzzy(Juhn)', id='text_contains_fuzzy'),
+            param(Text.text_not_contains_fuzzy('Juhn'), 'textNotContainsFuzzy(Juhn)', id='text_not_contains_fuzzy'),
             param(Text.text_contains_regex('.*hn.*'), 'textContainsRegex(.*hn.*)', id='text_contains_regex'),
+            param(Text.text_not_contains_regex('.*hn.*'), 'textNotContainsRegex(.*hn.*)', id='text_not_contains_regex'),
+            param(Text.text_contains_phrase('John Doe'), 'textContainsPhrase(John Doe)', id='text_contains_phrase'),
+            param(Text.text_not_contains_phrase('John Doe'), 'textNotContainsPhrase(John Doe)', id='text_not_contains_phrase'),
             param(Text.text_fuzzy('Juhn'), 'textFuzzy(Juhn)', id='text_fuzzy'),
+            param(Text.text_not_fuzzy('Juhn'), 'textNotFuzzy(Juhn)', id='text_not_fuzzy'),
             param(Text.text_prefix('John'), 'textPrefix(John)', id='text_prefix'),
+            param(Text.text_not_prefix('John'), 'textNotPrefix(John)', id='text_not_prefix'),
             param(Text.text_regex('.*hn.*'), 'textRegex(.*hn.*)', id='text_regex'),
+            param(Text.text_not_regex('.*hn.*'), 'textNotRegex(.*hn.*)', id='text_not_regex'),
         ]
     )
     def test_Text(self, predicate, expected):

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`	`1`	`[docker]`
`2`		`-image = janusgraph/janusgraph:1.0.0`
	`2`	`+image = janusgraph/janusgraph:1.1.0`