Adding grep

Author: seperman

deepdiff/__init__.py

@@ -4,6 +4,6 @@
     logging.basicConfig(format='%(asctime)s %(levelname)8s %(message)s')
 
 from .diff import DeepDiff
-from .search import DeepSearch
+from .search import DeepSearch, grep
 from .contenthash import DeepHash
 from .helper import py3

deepdiff/helper.py

@@ -113,3 +113,22 @@ class Verbose(object):
     Global verbose level
     """
     level = 1
+
+
+if py3:
+    class filtered(filter):
+
+        @property
+        def listed(self):
+            self._listed = getattr(self, "_listed", list(self))
+            return self._listed
+
+        def __str__(self):
+            return str(self.listed)
+
+        __repr__ = __str__
+
+        def __eq__(self, other):
+            return self.listed == other
+else:
+    filtered = filter

deepdiff/search.py

@@ -10,7 +10,7 @@
 from collections import MutableMapping
 import logging
 
-from deepdiff.helper import py3, strings, numbers, items
+from deepdiff.helper import py3, strings, numbers, items, filtered
 
 logger = logging.getLogger(__name__)
 
@@ -77,6 +77,7 @@ def __init__(self,
                  exclude_paths=set(),
                  exclude_types=set(),
                  verbose_level=1,
+                 case_sensitive=False,
                  **kwargs):
         if kwargs:
             raise ValueError((
@@ -85,7 +86,8 @@ def __init__(self,
             ) % ', '.join(kwargs.keys()))
 
         self.obj = obj
-        self.item = item
+        self.case_sensitive = case_sensitive if isinstance(item, strings) else True
+        item = item if self.case_sensitive else item.lower()
         self.exclude_paths = set(exclude_paths)
         self.exclude_types = set(exclude_types)
         self.exclude_types_tuple = tuple(
@@ -180,8 +182,9 @@ def __search_dict(self,
             parents_ids_added = self.__add_to_frozen_set(parents_ids, item_id)
 
             new_parent = parent_text % (parent, item_key_str)
+            new_parent_cased = new_parent if self.case_sensitive else new_parent.lower()
 
-            if str(item) in new_parent:
+            if str(item) in new_parent_cased:
                 self.__report(
                     report_key='matched_paths',
                     key=new_parent,
@@ -200,25 +203,31 @@ def __search_iterable(self,
                           parents_ids=frozenset({})):
         """Search iterables except dictionaries, sets and strings."""
 
-        for i, x in enumerate(obj):
+        for i, thing in enumerate(obj):
             new_parent = "%s[%s]" % (parent, i)
-            if self.__skip_this(x, parent=new_parent):
+            if self.__skip_this(thing, parent=new_parent):
                 continue
-            if x == item:
+
+            if self.case_sensitive or not isinstance(thing, strings):
+                thing_cased = thing
+            else:
+                thing_cased = thing.lower()
+
+            if thing_cased == item:
                 self.__report(
-                    report_key='matched_values', key=new_parent, value=x)
+                    report_key='matched_values', key=new_parent, value=thing)
             else:
-                item_id = id(x)
+                item_id = id(thing)
                 if parents_ids and item_id in parents_ids:
                     continue
-                parents_ids_added = self.__add_to_frozen_set(parents_ids,
-                                                             item_id)
-                self.__search(x, item, "%s[%s]" %
+                parents_ids_added = self.__add_to_frozen_set(parents_ids, item_id)
+                self.__search(thing, item, "%s[%s]" %
                               (parent, i), parents_ids_added)
 
     def __search_str(self, obj, item, parent):
         """Compare strings"""
-        if item in obj:
+        obj_text = obj if self.case_sensitive else obj.lower()
+        if item in obj_text:
             self.__report(report_key='matched_values', key=parent, value=obj)
 
     def __search_numbers(self, obj, item, parent):
@@ -275,6 +284,21 @@ def __search(self, obj, item, parent="root", parents_ids=frozenset({})):
             self.__search_obj(obj, item, parent, parents_ids)
 
 
+class grep(object):
+    """
+    Grep!
+    """
+
+    def __init__(self,
+                 item,
+                 **kwargs):
+        self.item = item
+        self.kwargs = kwargs
+
+    def __ror__(self, other):
+        return DeepSearch(obj=other, item=self.item, **self.kwargs)
+
+
 if __name__ == "__main__":  # pragma: no cover
     if not py3:
         sys.exit("Please run with Python 3 to verify the doc strings.")

tests/test_search.py

@@ -11,10 +11,10 @@
     nosetests --with-coverage --cover-package=deepdiff
 
 To run a specific test, run this from the root of repo:
-    nosetests .\tests\search_tests.py:DeepSearchTestCase.test_string_in_root
+    nosetests tests/test_search.py:DeepSearchTestCase.test_case_insensitive_of_str_in_list
 """
 import unittest
-from deepdiff import DeepSearch
+from deepdiff import DeepSearch, grep
 import logging
 logging.disable(logging.CRITICAL)
 
@@ -98,6 +98,23 @@ def test_string_in_dictionary(self):
         ds = DeepSearch(obj, item, verbose_level=1)
         self.assertEqual(ds, result)
 
+    def test_string_in_dictionary_case_insensitive(self):
+        obj = {"long": "Somewhere over there!", "string": 2, 0: 0, "SOMEWHERE": "around"}
+        result = {
+            'matched_paths': {"root['SOMEWHERE']"},
+            'matched_values': {"root['long']"}
+        }
+        ds = DeepSearch(obj, item, verbose_level=1, case_sensitive=False)
+        self.assertEqual(ds, result)
+
+    def test_string_in_dictionary_key_case_insensitive_partial(self):
+        obj = {"SOMEWHERE here": "around"}
+        result = {
+            'matched_paths': {"root['SOMEWHERE here']"}
+        }
+        ds = DeepSearch(obj, item, verbose_level=1, case_sensitive=False)
+        self.assertEqual(ds, result)
+
     def test_string_in_dictionary_verbose(self):
         obj = {"long": "somewhere", "string": 2, 0: 0, "somewhere": "around"}
         result = {
@@ -244,3 +261,38 @@ def __str__(self):
         self.assertEqual(ds, result)
         ds = DeepSearch(obj, item, verbose_level=2)
         self.assertEqual(ds, result)
+
+    def test_case_insensitive_of_str_in_list(self):
+        obj = ["a", "bb", "BBC", "aBbB"]
+        item = "BB"
+        result = {"matched_values": {'root[1]', 'root[2]', 'root[3]'}}
+        self.assertEqual(DeepSearch(obj, item, verbose_level=1, case_sensitive=False), result)
+
+    def test_case_sensitive_of_str_in_list(self):
+        obj = ["a", "bb", "BBC", "aBbB"]
+        item = "BB"
+        result = {"matched_values": {'root[2]'}}
+        self.assertEqual(DeepSearch(obj, item, verbose_level=1, case_sensitive=True), result)
+
+    def test_case_sensitive_of_str_in_one_liner(self):
+        obj = "Hello, what's up?"
+        item = "WHAT"
+        result = {}
+        self.assertEqual(DeepSearch(obj, item, verbose_level=1, case_sensitive=True), result)
+
+    def test_case_insensitive_of_str_in_one_liner(self):
+        obj = "Hello, what's up?"
+        item = "WHAT"
+        result = {'matched_values': {'root'}}
+        self.assertEqual(DeepSearch(obj, item, verbose_level=1, case_sensitive=False), result)
+
+
+class GrepTestCase(unittest.TestCase):
+
+    def test_grep_dict(self):
+        obj = {
+            "for life": "vegan",
+            "ingredients": ["no meat", "no eggs", "no dairy", "somewhere"]
+        }
+        ds = obj | grep(item)
+        self.assertEqual(ds, {'matched_values': {"root['ingredients'][3]"}})