when strict check is false we convert the passed number into string

Author: seperman

CHANGELOG.md

@@ -1,5 +1,6 @@
 # DeepDiff Change log
 
+- v5-4-0: adding strict_checking for numbers in DeepSearch
 - v5-3-0: add support for regular expressions in DeepSearch
 - v5-2-3: Retaining the order of multiple dictionary items added via Delta. Fixed the typo with yml files in deep cli. Fixing Grep RecursionError where using non UTF-8 character. Allowing kwargs to be passed to to_json method.
 - v5-2-2: Fixed Delta serialization when None type is present.

deepdiff/search.py

@@ -43,9 +43,10 @@ class DeepSearch(dict):
         If False, the value of the item can be a part of the value of the object or its children
 
     use_regexp: Boolean, default = False
-    strict_checking: Boolean, default = False
-        If True, it won't check the type of the object to match, so '1234' will match
-            the int 1234.
+
+    strict_checking: Boolean, default = True
+        If True, it will check the type of the object to match, so when searching for '1234',
+        it will NOT match the int 1234. Currently this only affects the numeric values searching.
 
     **Returns**
 
@@ -114,8 +115,13 @@ def __init__(self,
             matched_values=self.__set_or_dict(),
             unprocessed=[])
         self.use_regexp = use_regexp
+        if not strict_checking and isinstance(item, numbers):
+            item = str(item)
         if self.use_regexp:
-            item = re.compile(item)
+            try:
+                item = re.compile(item)
+            except TypeError as e:
+                raise TypeError(f"The passed item of {item} is not usable for regex: {e}") from None
         self.strict_checking = strict_checking
 
         # Cases where user wants to match exact string item
@@ -272,9 +278,13 @@ def __search_str(self, obj, item, parent):
 
     def __search_numbers(self, obj, item, parent):
         if (
-            item == obj
-            or (not self.strict_checking and item == str(obj))
-            or (not self.strict_checking and self.use_regexp and item.search(str(obj)))
+            item == obj or (
+                not self.strict_checking and (
+                    item == str(obj) or (
+                        self.use_regexp and item.search(str(obj))
+                    )
+                )
+            )
         ):
             self.__report(report_key='matched_values', key=parent, value=obj)
 

docs/changelog.rst

@@ -5,6 +5,7 @@ Changelog
 
 DeepDiff Changelog
 
+- v5-4-0: adding strict_checking for numbers in DeepSearch
 - v5-3-0: add support for regular expressions in DeepSearch
 - v5-2-3: Retaining the order of multiple dictionary items added via Delta. Fixed the typo with yml files in deep cli. Fixing Grep RecursionError where using non UTF-8 character. Allowing kwargs to be passed to to_json method.
 - v5-2-2: Fixed Delta serialization when None type is present.

docs/search_doc.rst

@@ -1,5 +1,33 @@
-grep is a more user friendly interface for DeepSearch. It takes exactly the same arguments as DeepSearch.
-And it works just like grep in linux shell!
+grep is a more user friendly interface for DeepSearch. It takes exactly the same arguments as DeepSearch except that you pipe the object into it instead of passing it as a parameter.
+
+It works just like grep in linux shell!
+
+**Parameters**
+
+item : The item to search for
+
+verbose_level : int >= 0, default = 1.
+    Verbose level one shows the paths of found items.
+    Verbose level 2 shows the path and value of the found items.
+
+exclude_paths: list, default = None.
+    List of paths to exclude from the report.
+
+exclude_types: list, default = None.
+    List of object types to exclude from the report.
+
+case_sensitive: Boolean, default = False
+
+match_string: Boolean, default = False
+    If True, the value of the object or its children have to exactly match the item.
+    If False, the value of the item can be a part of the value of the object or its children
+
+use_regexp: Boolean, default = False
+
+strict_checking: Boolean, default = True
+    If True, it will check the type of the object to match, so when searching for '1234',
+    it will NOT match the int 1234. Currently this only affects the numeric values searching.
+
 
 **Examples**
 
@@ -28,3 +56,16 @@ You can also use regular expressions
     >>> ds = obj | grep("some.*", use_regexp=True)
     { 'matched_paths': ["root[1]['someone']", "root[1]['somewhere']"],
       'matched_values': ['root[0]', "root[1]['long']"]}
+
+
+Change strict_checking to False to match numbers in strings and vice versa:
+    >>> obj = {"long": "somewhere", "num": 1123456, 0: 0, "somewhere": "around"}
+    >>> item = "1234"
+    >>> result = {"matched_values": {"root['num']"}}
+    >>> ds = obj | grep(item, verbose_level=1, use_regexp=True)
+    >>> pprint(ds)
+    {}
+    >>>
+    >>> ds = obj | grep(item, verbose_level=1, use_regexp=True, strict_checking=False)
+    >>> pprint(ds)
+    {'matched_values': ["root['num']"]}

tests/test_search.py

@@ -452,6 +452,21 @@ def test_regex_in_int_in_dictionary_returns_partial_match(self):
         ds = DeepSearch(obj, item, verbose_level=1, use_regexp=True, strict_checking=False)
         assert ds == result
 
+    def test_int_cant_become_regex(self):
+        obj = {"long": "somewhere", "num": "1123456", 0: 0, "somewhere": "around"}
+        item = CustomClass(a=10)
+        with pytest.raises(TypeError) as exp:
+            DeepSearch(obj, item, verbose_level=1, use_regexp=True, strict_checking=False)
+        assert str(exp.value).startswith("The passed item of (10, None) is not usable for regex")
+
+    def test_searching_for_int_in_dictionary_when_strict_false(self):
+        obj = {"long": "somewhere", "num": "1234", 0: 0, "somewhere": "around"}
+        item = 1234
+        result = {"matched_values": {"root['num']"}}
+        ds = DeepSearch(obj, item, verbose_level=1, strict_checking=False)
+        assert ds == result
+
+
 class TestGrep:
 
     def test_grep_dict(self):