Merge branch 'master' into feature/cleanup

Author: moomoohk

.github/workflows/deploy.yml

@@ -46,6 +46,7 @@ jobs:
         uses: loopwerk/tag-changelog@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
+          config_file: .github/tag-changelog-config.js
 
       - name: PyPI Deployment
         uses: casperdcl/deploy-pypi@v2

MAINTAINERS.md

@@ -10,7 +10,7 @@ There are several individuals in the community who have taken an active role in
 Where and How do we communicate
 ===============================
 
-The dpath maintainers communcate in 3 primary ways:
+The dpath maintainers communicate in 3 primary ways:
 
 1. Email, directly to each other.
 2. Github via issue and pull request comments

README.rst

@@ -49,10 +49,10 @@ Suppose we have a dictionary like this:
     x = {
         "a": {
             "b": {
-            "3": 2,
-            "43": 30,
-            "c": [],
-            "d": ['red', 'buggy', 'bumpers'],
+                "3": 2,
+                "43": 30,
+                "c": [],
+                "d": ['red', 'buggy', 'bumpers'],
             }
         }
     }
@@ -96,26 +96,26 @@ elements in ``x['a']['b']`` where the key is equal to the glob ``'[cd]'``. Okay.
 .. code-block:: pycon
 
     >>> result = dpath.util.search(x, "a/b/[cd]")
-    >>> print json.dumps(result, indent=4, sort_keys=True)
+    >>> print(json.dumps(result, indent=4, sort_keys=True))
     {
-    "a": {
-        "b": {
-        "c": [],
-        "d": [
-            "red",
-            "buggy",
-            "bumpers"
-        ]
+        "a": {
+            "b": {
+                "c": [],
+                "d": [
+                    "red",
+                    "buggy",
+                    "bumpers"
+                ]
+            }
         }
     }
-    }
 
 ... Wow that was easy. What if I want to iterate over the results, and
 not get a merged view?
 
 .. code-block:: pycon
 
-    >>> for x in dpath.util.search(x, "a/b/[cd]", yielded=True): print x
+    >>> for x in dpath.util.search(x, "a/b/[cd]", yielded=True): print(x)
     ...
     ('a/b/c', [])
     ('a/b/d', ['red', 'buggy', 'bumpers'])
@@ -154,7 +154,7 @@ value 'Waffles'.
 
     >>> dpath.util.set(x, 'a/b/[cd]', 'Waffles')
     2
-    >>> print json.dumps(x, indent=4, sort_keys=True)
+    >>> print(json.dumps(x, indent=4, sort_keys=True))
     {
         "a": {
             "b": {
@@ -188,7 +188,7 @@ necessary to get to the terminus.
     keys
 
     >>> dpath.util.new(x, 'a/b/e/f/g', "Roffle")
-    >>> print json.dumps(x, indent=4, sort_keys=True)
+    >>> print(json.dumps(x, indent=4, sort_keys=True))
     {
         "a": {
             "b": {
@@ -213,7 +213,7 @@ object with None entries in order to make it big enough:
 
     >>> dpath.util.new(x, 'a/b/e/f/h', [])
     >>> dpath.util.new(x, 'a/b/e/f/h/13', 'Wow this is a big array, it sure is lonely in here by myself')
-    >>> print json.dumps(x, indent=4, sort_keys=True)
+    >>> print(json.dumps(x, indent=4, sort_keys=True))
     {
         "a": {
             "b": {
@@ -290,59 +290,59 @@ does.
               replaces the destination in this situation.
 
     >>> y = {'a': {'b': { 'e': {'f': {'h': [None, 0, 1, None, 13, 14]}}}, 'c': 'RoffleWaffles'}}
-    >>> print json.dumps(y, indent=4, sort_keys=True)
+    >>> print(json.dumps(y, indent=4, sort_keys=True))
     {
-    "a": {
-        "b": {
-        "e": {
-            "f": {
-            "h": [
-                null,
-                0,
-                1,
-                null,
-                13,
-                14
-            ]
-            }
+        "a": {
+            "b": {
+                "e": {
+                    "f": {
+                        "h": [
+                            null,
+                            0,
+                            1,
+                            null,
+                            13,
+                            14
+                        ]
+                    }
+                }
+            },
+            "c": "RoffleWaffles"
         }
-        },
-        "c": "RoffleWaffles"
-    }
     }
     >>> dpath.util.merge(x, y)
-    >>> print json.dumps(x, indent=4, sort_keys=True)
+    >>> print(json.dumps(x, indent=4, sort_keys=True))
     {
-    "a": {
-        "b": {
-        "3": 2,
-        "43": 30,
-        "c": "Waffles",
-        "d": "Waffles",
-        "e": {
-            "f": {
-            "g": "Roffle",
-            "h": [
-                null,
-                0,
-                1,
-                null,
-                13,
-                14,
-                null,
-                null,
-                null,
-                null,
-                null,
-                null,
-                null,
-                "Wow this is a big array, it sure is lonely in here by myself"
-            ]
-            }
+        "a": {
+            "b": {
+                "3": 2,
+                "43": 30,
+                "c": "Waffles",
+                "d": "Waffles",
+                "e": {
+                    "f": {
+                        "g": "Roffle",
+                        "h": [
+                            null,
+                            0,
+                            1,
+                            null,
+                            13,
+                            14,
+                            null,
+                            null,
+                            null,
+                            null,
+                            null,
+                            null,
+                            null,
+                            "Wow this is a big array, it sure is lonely in here by myself"
+                        ]
+                    }
+                }
+            },
+            "c": "RoffleWaffles"
         }
-        },
-        "c": "RoffleWaffles"
-    }
     }
 
 Now that's handy. You shouldn't try to use this as a replacement for the
@@ -369,41 +369,41 @@ them:
 
 .. code-block:: pycon
 
-    >>> print json.dumps(x, indent=4, sort_keys=True)
+    >>> print(json.dumps(x, indent=4, sort_keys=True))
     {
-    "a": {
-        "b": {
-        "3": 2,
-        "43": 30,
-        "c": "Waffles",
-        "d": "Waffles",
-        "e": {
-            "f": {
-            "g": "Roffle"
+        "a": {
+            "b": {
+                "3": 2,
+                "43": 30,
+                "c": "Waffles",
+                "d": "Waffles",
+                "e": {
+                    "f": {
+                        "g": "Roffle"
+                    }
+                }
             }
         }
-        }
-    }
     }
     >>> def afilter(x):
     ...     if "ffle" in str(x):
     ...             return True
     ...     return False
     ...
     >>> result = dpath.util.search(x, '**', afilter=afilter)
-    >>> print json.dumps(result, indent=4, sort_keys=True)
+    >>> print(json.dumps(result, indent=4, sort_keys=True))
     {
-    "a": {
-        "b": {
-        "c": "Waffles",
-        "d": "Waffles",
-        "e": {
-            "f": {
-            "g": "Roffle"
+        "a": {
+            "b": {
+                "c": "Waffles",
+                "d": "Waffles",
+                "e": {
+                    "f": {
+                      "g": "Roffle"
+                    }
+                }
             }
         }
-        }
-    }
     }
 
 Obviously filtering functions can perform more advanced tests (regular

dpath/options.py

@@ -1 +1,2 @@
 ALLOW_EMPTY_STRING_KEYS = False
+CONVERT_INT_LIKE_SEGMENTS = True

dpath/util.py

@@ -60,14 +60,15 @@ def _split_path(path: str, separator: str) -> Union[List[PathSegment], PathSegme
     else:
         split_segments = path.lstrip(separator).split(separator)
 
-        # Attempt to convert integer segments into actual integers.
-        final = []
-        for segment in split_segments:
-            try:
-                final.append(int(segment))
-            except:
-                final.append(segment)
-        split_segments = final
+        if options.CONVERT_INT_LIKE_SEGMENTS:
+            # Attempt to convert integer segments into actual integers.
+            final = []
+            for segment in split_segments:
+                try:
+                    final.append(int(segment))
+                except:
+                    final.append(segment)
+            split_segments = final
 
     return split_segments
 

dpath/version.py

@@ -1 +1 @@
-VERSION = "2.0.4"
+VERSION = "2.0.6"