python-benedict 0.34.0__tar.gz → 0.35.0__tar.gz

{python_benedict-0.34.0/python_benedict.egg-info → python_benedict-0.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-benedict
-Version: 0.34.0
+Version: 0.35.0
 Summary: python-benedict is a dict subclass with keylist/keypath/keyattr support, normalized I/O operations (base64, csv, ini, json, pickle, plist, query-string, toml, xls, xml, yaml) and many utilities... for humans, obviously.
 Author-email: Fabio Caccamo <fabio.caccamo@gmail.com>
 Maintainer-email: Fabio Caccamo <fabio.caccamo@gmail.com>
@@ -56,11 +56,14 @@ Classifier: Topic :: Software Development :: Build Tools
 Classifier: Topic :: System :: Filesystems
 Classifier: Topic :: Text Processing :: Markup :: XML
 Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: python-fsutil<1.0.0,>=0.9.3
 Requires-Dist: python-slugify<9.0.0,>=7.0.0
 Requires-Dist: requests<3.0.0,>=2.26.0
+Requires-Dist: typing_extensions<4.16.0,>=4.13.2
+Requires-Dist: useful-types<0.3.0,>=0.2.1
 Provides-Extra: all
 Requires-Dist: python-benedict[io,parse,s3]; extra == "all"
 Provides-Extra: html
@@ -71,7 +74,7 @@ Requires-Dist: python-benedict[html,toml,xls,xml,yaml]; extra == "io"
 Provides-Extra: parse
 Requires-Dist: ftfy<7.0.0,>=6.0.0; extra == "parse"
 Requires-Dist: mailchecker<7.0.0,>=4.1.0; extra == "parse"
-Requires-Dist: phonenumbers<9.0.0,>=8.12.0; extra == "parse"
+Requires-Dist: phonenumbers<10.0.0,>=8.12.0; extra == "parse"
 Requires-Dist: python-dateutil<3.0.0,>=2.8.0; extra == "parse"
 Provides-Extra: s3
 Requires-Dist: boto3<2.0.0,>=1.24.89; extra == "s3"
@@ -81,9 +84,10 @@ Provides-Extra: xls
 Requires-Dist: openpyxl<4.0.0,>=3.0.0; extra == "xls"
 Requires-Dist: xlrd<3.0.0,>=2.0.0; extra == "xls"
 Provides-Extra: xml
-Requires-Dist: xmltodict<1.0.0,>=0.12.0; extra == "xml"
+Requires-Dist: xmltodict<2.0.0,>=0.12.0; extra == "xml"
 Provides-Extra: yaml
 Requires-Dist: pyyaml<7.0,>=6.0; extra == "yaml"
+Dynamic: license-file
 
 [![](https://img.shields.io/pypi/pyversions/python-benedict.svg?color=blue&logo=python&logoColor=white)](https://www.python.org/)
 [![](https://img.shields.io/pypi/v/python-benedict.svg?color=blue&logo=pypi&logoColor=white)](https://pypi.org/project/python-benedict/)
@@ -94,7 +98,6 @@ Requires-Dist: pyyaml<7.0,>=6.0; extra == "yaml"
 [![](https://results.pre-commit.ci/badge/github/fabiocaccamo/python-benedict/main.svg)](https://results.pre-commit.ci/latest/github/fabiocaccamo/python-benedict/main)
 [![](https://img.shields.io/github/actions/workflow/status/fabiocaccamo/python-benedict/test-package.yml?branch=main&label=build&logo=github)](https://github.com/fabiocaccamo/python-benedict)
 [![](https://img.shields.io/codecov/c/gh/fabiocaccamo/python-benedict?logo=codecov)](https://codecov.io/gh/fabiocaccamo/python-benedict)
-[![](https://img.shields.io/codeclimate/maintainability/fabiocaccamo/python-benedict?logo=code-climate)](https://codeclimate.com/github/fabiocaccamo/python-benedict/)
 [![](https://img.shields.io/codacy/grade/0dbd5cc2089f4dce80a0e49e6822be3c?logo=codacy)](https://www.codacy.com/app/fabiocaccamo/python-benedict)
 [![](https://img.shields.io/scrutinizer/quality/g/fabiocaccamo/python-benedict?logo=scrutinizer)](https://scrutinizer-ci.com/g/fabiocaccamo/python-benedict/?branch=main)
 [![](https://img.shields.io/badge/code%20style-black-000000.svg?logo=python&logoColor=black)](https://github.com/psf/black)
@@ -217,7 +220,7 @@ d.keyattr_dynamic = True
 > **Warning** - even if this feature is very useful, it has some obvious limitations: it works only for string keys that are *unprotected* (not starting with an `_`) and that don't clash with the currently supported methods names.
 
 ### Keylist
-Wherever a **key** is used, it is possible to use also a **list (or a tuple) of keys**.
+Wherever a **key** is used, it is possible to use also a **list of keys**.
 
 ```python
 d = benedict()
@@ -545,7 +548,8 @@ items = d.items_sorted_by_values(reverse=False)
 ```python
 # Return a list of all keypaths in the dict.
 # If indexes is True, the output will include list values indexes.
-k = d.keypaths(indexes=False)
+# If sort is True, the resulting list will be sorted
+k = d.keypaths(indexes=False, sort=True)
 ```
 
 #### `match`
@@ -1126,7 +1130,7 @@ Released under [MIT License](LICENSE.txt).
 
 - :star: Star this project on [GitHub](https://github.com/fabiocaccamo/python-benedict)
 - :octocat: Follow me on [GitHub](https://github.com/fabiocaccamo)
-- :blue_heart: Follow me on [Twitter](https://twitter.com/fabiocaccamo)
+- :blue_heart: Follow me on [Bluesky](https://bsky.app/profile/fabiocaccamo.bsky.social)
 - :moneybag: Sponsor me on [Github](https://github.com/sponsors/fabiocaccamo)
 
 ## See also

{python_benedict-0.34.0 → python_benedict-0.35.0}/README.md

@@ -7,7 +7,6 @@
 [![](https://results.pre-commit.ci/badge/github/fabiocaccamo/python-benedict/main.svg)](https://results.pre-commit.ci/latest/github/fabiocaccamo/python-benedict/main)
 [![](https://img.shields.io/github/actions/workflow/status/fabiocaccamo/python-benedict/test-package.yml?branch=main&label=build&logo=github)](https://github.com/fabiocaccamo/python-benedict)
 [![](https://img.shields.io/codecov/c/gh/fabiocaccamo/python-benedict?logo=codecov)](https://codecov.io/gh/fabiocaccamo/python-benedict)
-[![](https://img.shields.io/codeclimate/maintainability/fabiocaccamo/python-benedict?logo=code-climate)](https://codeclimate.com/github/fabiocaccamo/python-benedict/)
 [![](https://img.shields.io/codacy/grade/0dbd5cc2089f4dce80a0e49e6822be3c?logo=codacy)](https://www.codacy.com/app/fabiocaccamo/python-benedict)
 [![](https://img.shields.io/scrutinizer/quality/g/fabiocaccamo/python-benedict?logo=scrutinizer)](https://scrutinizer-ci.com/g/fabiocaccamo/python-benedict/?branch=main)
 [![](https://img.shields.io/badge/code%20style-black-000000.svg?logo=python&logoColor=black)](https://github.com/psf/black)
@@ -130,7 +129,7 @@ d.keyattr_dynamic = True
 > **Warning** - even if this feature is very useful, it has some obvious limitations: it works only for string keys that are *unprotected* (not starting with an `_`) and that don't clash with the currently supported methods names.
 
 ### Keylist
-Wherever a **key** is used, it is possible to use also a **list (or a tuple) of keys**.
+Wherever a **key** is used, it is possible to use also a **list of keys**.
 
 ```python
 d = benedict()
@@ -458,7 +457,8 @@ items = d.items_sorted_by_values(reverse=False)
 ```python
 # Return a list of all keypaths in the dict.
 # If indexes is True, the output will include list values indexes.
-k = d.keypaths(indexes=False)
+# If sort is True, the resulting list will be sorted
+k = d.keypaths(indexes=False, sort=True)
 ```
 
 #### `match`
@@ -1039,7 +1039,7 @@ Released under [MIT License](LICENSE.txt).
 
 - :star: Star this project on [GitHub](https://github.com/fabiocaccamo/python-benedict)
 - :octocat: Follow me on [GitHub](https://github.com/fabiocaccamo)
-- :blue_heart: Follow me on [Twitter](https://twitter.com/fabiocaccamo)
+- :blue_heart: Follow me on [Bluesky](https://bsky.app/profile/fabiocaccamo.bsky.social)
 - :moneybag: Sponsor me on [Github](https://github.com/sponsors/fabiocaccamo)
 
 ## See also

{python_benedict-0.34.0 → python_benedict-0.35.0}/benedict/core/clean.py

@@ -1,4 +1,16 @@
-def _clean_dict(d, strings, collections):
+from __future__ import annotations
+
+from collections.abc import MutableMapping, MutableSequence
+from typing import Any, TypeVar
+
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+_T = TypeVar("_T")
+
+
+def _clean_dict(
+    d: MutableMapping[_K, _V], strings: bool, collections: bool
+) -> MutableMapping[_K, _V]:
     keys = list(d.keys())
     for key in keys:
         d[key] = _clean_value(d[key], strings=strings, collections=collections)
@@ -7,7 +19,9 @@ def _clean_dict(d, strings, collections):
     return d
 
 
-def _clean_list(ls, strings, collections):
+def _clean_list(
+    ls: MutableSequence[_T], strings: bool, collections: bool
+) -> MutableSequence[_T]:
     for i in range(len(ls) - 1, -1, -1):
         ls[i] = _clean_value(ls[i], strings=strings, collections=collections)
         if ls[i] is None:
@@ -15,7 +29,7 @@ def _clean_list(ls, strings, collections):
     return ls
 
 
-def _clean_set(values, strings, collections):
+def _clean_set(values: set[_T], strings: bool, collections: bool) -> set[_T]:
     return {
         value
         for value in values
@@ -23,11 +37,13 @@ def _clean_set(values, strings, collections):
     }
 
 
-def _clean_str(s, strings, collections):
+def _clean_str(s: str, strings: bool, collections: bool) -> str | None:
     return s if s and s.strip() else None
 
 
-def _clean_tuple(values, strings, collections):
+def _clean_tuple(
+    values: tuple[_T, ...], strings: bool, collections: bool
+) -> tuple[_T, ...]:
     return tuple(
         value
         for value in values
@@ -35,13 +51,15 @@ def _clean_tuple(values, strings, collections):
     )
 
 
-def _clean_value(value, strings, collections):
+def _clean_value(value: Any, strings: bool, collections: bool) -> Any:
     if value is None:
         return value
-    elif isinstance(value, list) and collections:
+    elif isinstance(value, MutableSequence) and collections:
         value = _clean_list(value, strings=strings, collections=collections) or None
-    elif isinstance(value, dict) and collections:
-        value = _clean_dict(value, strings=strings, collections=collections) or None
+    elif isinstance(value, MutableMapping) and collections:
+        value = (
+            _clean_dict(dict(value), strings=strings, collections=collections) or None
+        )
     elif isinstance(value, set) and collections:
         value = _clean_set(value, strings=strings, collections=collections) or None
     elif isinstance(value, str) and strings:
@@ -51,5 +69,5 @@ def _clean_value(value, strings, collections):
     return value
 
 
-def clean(d, strings=True, collections=True):
+def clean(d: Any, strings: bool = True, collections: bool = True) -> Any:
     return _clean_dict(d, strings=strings, collections=collections)

python_benedict-0.35.0/benedict/core/clone.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import copy
+from collections.abc import MutableMapping
+from typing import Any, TypeVar
+
+_T = TypeVar("_T")
+
+
+def clone(
+    obj: _T,
+    empty: bool = False,
+    memo: dict[int, Any] | None = None,
+) -> _T:
+    d = copy.deepcopy(obj, memo)
+    if empty and isinstance(d, MutableMapping):
+        d.clear()
+    return d

{python_benedict-0.34.0 → python_benedict-0.35.0}/benedict/core/dump.py

@@ -1,7 +1,9 @@
+from typing import Any
+
 from benedict.serializers import JSONSerializer
 
 
-def dump(obj, **kwargs):
+def dump(obj: Any, **kwargs: Any) -> str:
     serializer = JSONSerializer()
     options = {"indent": 4, "sort_keys": True}
     options.update(**kwargs)

python_benedict-0.35.0/benedict/core/filter.py

@@ -0,0 +1,21 @@
+from collections.abc import Callable, MutableMapping
+from typing import TypeVar
+
+from benedict.core.clone import clone
+
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+
+
+def filter(
+    d: MutableMapping[_K, _V], predicate: Callable[[_K, _V], bool]
+) -> MutableMapping[_K, _V]:
+    if not callable(predicate):
+        raise ValueError("predicate argument must be a callable.")
+    new_dict = clone(d, empty=True)
+    keys = list(d.keys())
+    for key in keys:
+        value = d[key]
+        if predicate(key, value):
+            new_dict[key] = value
+    return new_dict

python_benedict-0.35.0/benedict/core/find.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from typing import TypeVar
+
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+
+
+def find(
+    d: Mapping[_K, _V], keys: Iterable[_K], default: _V | None = None
+) -> _V | None:
+    for key in keys:
+        if key in d:
+            return d[key]
+    return default

{python_benedict-0.34.0 → python_benedict-0.35.0}/benedict/core/flatten.py

@@ -1,20 +1,27 @@
-from benedict.core import clone
-from benedict.utils import type_util
+from collections.abc import Mapping
+from typing import Any
 
+from benedict.core.clone import clone
 
-def _flatten_key(base_key, key, separator):
+
+def _flatten_key(base_key: str, key: str, separator: str) -> str:
     if base_key and separator:
         return f"{base_key}{separator}{key}"
     return key
 
 
-def _flatten_item(d, base_dict, base_key, separator):
+def _flatten_item(
+    d: Any,
+    base_dict: Any,
+    base_key: str,
+    separator: str,
+) -> Any:
     new_dict = base_dict
     keys = list(d.keys())
     for key in keys:
         new_key = _flatten_key(base_key, key, separator)
         value = d.get(key, None)
-        if type_util.is_dict(value):
+        if isinstance(value, Mapping):
             new_value = _flatten_item(
                 value, base_dict=new_dict, base_key=new_key, separator=separator
             )
@@ -26,6 +33,6 @@ def _flatten_item(d, base_dict, base_key, separator):
     return new_dict
 
 
-def flatten(d, separator="_"):
+def flatten(d: Any, separator: str = "_") -> Any:
     new_dict = clone(d, empty=True)
     return _flatten_item(d, base_dict=new_dict, base_key="", separator=separator)

{python_benedict-0.34.0 → python_benedict-0.35.0}/benedict/core/groupby.py

@@ -1,10 +1,18 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, MutableSequence, Sequence
+from typing import Any, TypeVar
+
 from benedict.utils import type_util
 
+_K = TypeVar("_K")
+_V = TypeVar("_V", bound=MutableSequence[Any])
+
 
-def groupby(items, key):
+def groupby(items: Sequence[Mapping[_K, Any]], key: _K) -> dict[Any, Any]:
     if not type_util.is_list(items):
         raise ValueError("items should be a list of dicts.")
-    items_grouped = {}
+    items_grouped: dict[Any, Any] = {}
     for item in items:
         if not type_util.is_dict(item):
             raise ValueError("item should be a dict.")

{python_benedict-0.34.0 → python_benedict-0.35.0}/benedict/core/invert.py

@@ -1,20 +1,28 @@
-from benedict.core import clone
+from collections.abc import MutableMapping, Sequence
+from typing import Any, TypeVar
+
+from benedict.core.clone import clone
 from benedict.utils import type_util
 
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+
 
-def _invert_item(d, key, value, flat):
+def _invert_item(d: MutableMapping[Any, Any], key: _K, value: _V, flat: bool) -> None:
     if flat:
         d.setdefault(value, key)
     else:
         d.setdefault(value, []).append(key)
 
 
-def _invert_list(d, key, value, flat):
+def _invert_list(
+    d: MutableMapping[Any, Any], key: _K, value: Sequence[Any], flat: bool
+) -> None:
     for value_item in value:
         _invert_item(d, key, value_item, flat)
 
 
-def invert(d, flat=False):
+def invert(d: MutableMapping[_K, _V], flat: bool = False) -> MutableMapping[Any, Any]:
     new_dict = clone(d, empty=True)
     for key, value in d.items():
         if type_util.is_list_or_tuple(value):

python_benedict-0.35.0/benedict/core/items_sorted.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from useful_types import SupportsRichComparisonT
+
+
+def _items_sorted_by_item_at_index(
+    d: Mapping[SupportsRichComparisonT, SupportsRichComparisonT],
+    index: int,
+    reverse: bool,
+) -> list[tuple[SupportsRichComparisonT, SupportsRichComparisonT]]:
+    return sorted(d.items(), key=lambda item: item[index], reverse=reverse)
+
+
+def items_sorted_by_keys(
+    d: Mapping[SupportsRichComparisonT, SupportsRichComparisonT], reverse: bool = False
+) -> list[tuple[SupportsRichComparisonT, SupportsRichComparisonT]]:
+    return _items_sorted_by_item_at_index(d, 0, reverse)
+
+
+def items_sorted_by_values(
+    d: Mapping[SupportsRichComparisonT, SupportsRichComparisonT], reverse: bool = False
+) -> list[tuple[SupportsRichComparisonT, SupportsRichComparisonT]]:
+    return _items_sorted_by_item_at_index(d, 1, reverse)

{python_benedict-0.34.0 → python_benedict-0.35.0}/benedict/core/keylists.py

@@ -1,7 +1,14 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any
+
 from benedict.utils import type_util
 
 
-def _get_keylist_for_dict(d, parent_keys, indexes):
+def _get_keylist_for_dict(
+    d: Mapping[Any, Any], parent_keys: list[Any], indexes: bool
+) -> list[list[Any]]:
     keylist = []
     for key, value in d.items():
         keys = parent_keys + [key]
@@ -10,7 +17,9 @@ def _get_keylist_for_dict(d, parent_keys, indexes):
     return keylist
 
 
-def _get_keylist_for_list(ls, parent_keys, indexes):
+def _get_keylist_for_list(
+    ls: Sequence[Any], parent_keys: list[Any], indexes: bool
+) -> list[list[Any]]:
     keylist = []
     for key, value in enumerate(ls):
         keys = list(parent_keys)
@@ -20,7 +29,9 @@ def _get_keylist_for_list(ls, parent_keys, indexes):
     return keylist
 
 
-def _get_keylist_for_value(value, parent_keys, indexes):
+def _get_keylist_for_value(
+    value: Mapping[Any, Any] | Sequence[Any], parent_keys: list[Any], indexes: bool
+) -> list[list[Any]]:
     if type_util.is_dict(value):
         return _get_keylist_for_dict(value, parent_keys, indexes)
     elif type_util.is_list(value) and indexes:
@@ -28,5 +39,7 @@ def _get_keylist_for_value(value, parent_keys, indexes):
     return []
 
 
-def keylists(d, indexes=False):
+def keylists(
+    d: Mapping[Any, Any] | Sequence[Any], indexes: bool = False
+) -> list[list[Any]]:
     return _get_keylist_for_value(d, [], indexes)

{python_benedict-0.34.0 → python_benedict-0.35.0}/benedict/core/keypaths.py

@@ -1,12 +1,23 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
 from benedict.core.keylists import keylists
 from benedict.utils import type_util
 
 
-def keypaths(d, separator=".", indexes=False):
+def keypaths(
+    d: Mapping[Any, Any],
+    separator: str | None = ".",
+    indexes: bool = False,
+    sort: bool = True,
+) -> list[str]:
     separator = separator or "."
     if not type_util.is_string(separator):
         raise ValueError("separator argument must be a (non-empty) string.")
     kls = keylists(d, indexes=indexes)
     kps = [separator.join([f"{key}" for key in kl]) for kl in kls]
-    kps.sort()
+    if sort:
+        kps.sort()
     return kps

{python_benedict-0.34.0 → python_benedict-0.35.0}/benedict/core/match.py

@@ -1,10 +1,19 @@
+from __future__ import annotations
+
 import re
+from collections.abc import Mapping
+from typing import Any
 
 from benedict.core.keypaths import keypaths
 from benedict.utils import type_util
 
 
-def match(d, pattern, separator=".", indexes=True):
+def match(
+    d: Mapping[Any, Any],
+    pattern: str | re.Pattern[str],
+    separator: str | None = ".",
+    indexes: bool = True,
+) -> list[Any]:
     if type_util.is_regex(pattern):
         regex = pattern
     elif type_util.is_string(pattern):

{python_benedict-0.34.0 → python_benedict-0.35.0}/benedict/core/merge.py

@@ -1,25 +1,44 @@
+from collections.abc import Mapping, MutableMapping
+from typing import Any, TypeVar
+
 from benedict.utils import type_util
 
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+
 
-def _merge_dict(d, other, overwrite=True, concat=False):
+def _merge_dict(
+    d: MutableMapping[_K, _V],
+    other: Mapping[_K, _V],
+    overwrite: bool = True,
+    concat: bool = False,
+) -> None:
     for key, value in other.items():
         _merge_item(d, key, value, overwrite=overwrite, concat=concat)
 
 
-def _merge_item(d, key, value, overwrite=True, concat=False):
+def _merge_item(
+    d: MutableMapping[_K, _V],
+    key: _K,
+    value: _V,
+    overwrite: bool = True,
+    concat: bool = False,
+) -> None:
     if key in d:
-        item = d.get(key, None)
+        item = d.get(key)
         if type_util.is_dict(item) and type_util.is_dict(value):
             _merge_dict(item, value, overwrite=overwrite, concat=concat)
         elif concat and type_util.is_list(item) and type_util.is_list(value):
-            item += value
+            item += value  # type: ignore[assignment]
         elif overwrite:
             d[key] = value
     else:
         d[key] = value
 
 
-def merge(d, other, *args, **kwargs):
+def merge(
+    d: MutableMapping[_K, _V], other: Mapping[_K, _V], *args: Any, **kwargs: Any
+) -> Any:
     overwrite = kwargs.get("overwrite", True)
     concat = kwargs.get("concat", False)
     others = [other] + list(args)

{python_benedict-0.34.0 → python_benedict-0.35.0}/benedict/core/move.py

@@ -1,4 +1,12 @@
-def move(d, key_src, key_dest, overwrite=True):
+from collections.abc import MutableMapping
+from typing import Any, TypeVar
+
+_K = TypeVar("_K")
+
+
+def move(
+    d: MutableMapping[_K, Any], key_src: _K, key_dest: _K, overwrite: bool = True
+) -> None:
     if key_dest == key_src:
         return
     if key_dest in d and not overwrite:

{python_benedict-0.34.0 → python_benedict-0.35.0}/benedict/core/nest.py

@@ -1,14 +1,29 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, MutableMapping, Sequence
+from typing import Any
+
 from benedict.core.groupby import groupby
 
 
-def _nest_items(nested_items, item, id_key, children_key):
+def _nest_items(
+    nested_items: MutableMapping[Any, list[Any]],
+    item: Any,
+    id_key: Any,
+    children_key: Any,
+) -> None:
     children_items = nested_items.pop(item[id_key], [])
     item[children_key] = children_items
     for child_item in children_items:
         _nest_items(nested_items, child_item, id_key, children_key)
 
 
-def nest(items, id_key, parent_id_key, children_key):
+def nest(
+    items: Sequence[Mapping[Any, Any]],
+    id_key: Any,
+    parent_id_key: Any,
+    children_key: Any,
+) -> list[Any] | None:
     if any(
         [id_key == parent_id_key, id_key == children_key, parent_id_key == children_key]
     ):

{python_benedict-0.34.0 → python_benedict-0.35.0}/benedict/core/remove.py

@@ -1,7 +1,10 @@
+from collections.abc import MutableMapping
+from typing import Any
+
 from benedict.utils import type_util
 
 
-def remove(d, keys, *args):
+def remove(d: MutableMapping[Any, Any], keys: Any, *args: Any) -> None:
     if type_util.is_string(keys):
         keys = [keys]
     keys += args

python_benedict-0.35.0/benedict/core/rename.py

@@ -0,0 +1,10 @@
+from collections.abc import MutableMapping
+from typing import Any, TypeVar
+
+from benedict.core.move import move
+
+_K = TypeVar("_K")
+
+
+def rename(d: MutableMapping[_K, Any], key: _K, key_new: _K) -> None:
+    move(d, key, key_new, overwrite=False)

{python_benedict-0.34.0 → python_benedict-0.35.0}/benedict/core/search.py

@@ -1,26 +1,45 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, MutableMapping, Sequence
+from typing import Any, TypeVar
+
 from benedict.core.traverse import traverse
 from benedict.utils import type_util
 
+_K = TypeVar("_K")
+_V = TypeVar("_V")
+
 
-def _get_term(value, case_sensitive):
+def _get_term(value: Any, case_sensitive: bool) -> tuple[Any, bool]:
     v_is_str = type_util.is_string(value)
     v = value.lower() if (v_is_str and not case_sensitive) else value
     return (v, v_is_str)
 
 
-def _get_match(query, value, exact, case_sensitive):
+def _get_match(query: Any, value: Any, exact: bool, case_sensitive: bool) -> bool:
     q, q_is_str = _get_term(query, case_sensitive)
     v, v_is_str = _get_term(value, case_sensitive)
     # TODO: add regex support
     if q_is_str and v_is_str and not exact:
         return q in v
-    return q == v
+    return bool(q == v)
 
 
-def search(d, query, in_keys=True, in_values=True, exact=False, case_sensitive=True):
+def search(
+    d: MutableMapping[_K, _V],
+    query: Any,
+    in_keys: bool = True,
+    in_values: bool = True,
+    exact: bool = False,
+    case_sensitive: bool = True,
+) -> list[tuple[Any, Any, Any]]:
     items = []
 
-    def _search_item(item_dict, item_key, item_value):
+    def _search_item(
+        item_dict: Mapping[_K, _V] | Sequence[Any] | None,
+        item_key: _K | int,
+        item_value: _V | None,
+    ) -> None:
         match_key = in_keys and _get_match(query, item_key, exact, case_sensitive)
         match_val = in_values and _get_match(query, item_value, exact, case_sensitive)
         if any([match_key, match_val]):