deep-apply 1.0.0__tar.gz

deep_apply-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Zairon Jacobs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

deep_apply-1.0.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.2
+Name: deep-apply
+Version: 1.0.0
+Summary: Deep traverse through an object and apply a function on its values.
+Home-page: https://github.com/zaironjacobs/deep-apply
+Download-URL: https://github.com/zaironjacobs/deep-apply/archive/v1.0.0.tar.gz
+Author: Zairon Jacobs
+Author-email: zaironjacobs@gmail.com
+License: MIT
+Keywords: deep,traverse,apply,object,list,set,tuple,pydantic,dict
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Natural Language :: English
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.4.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Deep Apply
+
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/deep-apply?color=blue)](https://pypi.python.org/pypi/deep-apply)
+[![PyPI](https://img.shields.io/pypi/v/deep-apply?color=blue)](https://pypi.python.org/pypi/deep-apply)
+[![PyPI - License](https://img.shields.io/pypi/l/deep-apply)](https://pypi.python.org/pypi/deep-apply)
+
+[![tests](https://github.com/zaironjacobs/deep-apply/actions/workflows/test.yml/badge.svg)](https://github.com/zaironjacobs/deep-apply/actions/workflows/test.yml)
+
+Deep traverse through an object and apply a function on its values.
+
+Supports the following objects:
+
+* Dictionaries
+* Lists
+* Sets
+* Tuples
+* Pydantic models
+
+### Install
+
+```bash
+pip install deep-apply
+```
+
+### Usage
+
+#### Apply upper() on values
+
+```python
+import deep_apply
+
+
+# 1. Create your callback function. Will call upper() on strings.
+def to_upper(value, **kwargs):
+    """
+    To uppercase.
+    """
+
+    # Apply upper() and return the value
+    if isinstance(value, str):
+        return value.upper()
+
+    return value
+
+
+# 2. Your data.
+data = [
+    {
+        "id": "pZnZMffPCpJx",
+        "name": "John Doe",
+        "hobbies": {
+            "id": "OlVZysGsIywW",
+            "sport": ["football", "tennis"],
+            "music": ["singing", "guitar", "piano"],
+        },
+    }
+]
+
+# 3. Run apply()
+data = deep_apply.apply(data=data, func=to_upper)
+```
+
+#### Result
+
+```json
+[
+  {
+    "id": "PZNZMFFPCPJX",
+    "name": "JOHN DOE",
+    "hobbies": {
+      "id": "OLVZYSGSIYWW",
+      "sport": [
+        "FOOTBALL",
+        "TENNIS"
+      ],
+      "music": [
+        "SINGING",
+        "GUITAR",
+        "PIANO"
+      ]
+    }
+  }
+]
+```
+
+### Ignore keys
+
+You can get the current `key` or the current `depth` from `**kwargs` and add a condition e.g. to skip a specific key
+everywhere.
+
+```python
+def to_upper(value, **kwargs):
+    """
+    To uppercase.
+    """
+
+    key = kwargs.get("key")
+    depth = kwargs.get("depth")
+
+    ignore = False
+
+    # Ignore the key/field id everywhere (dictionaries or pydantic models)
+    if key == "id":
+        ignore = True
+
+    # Ignore the list of music found under hobbies
+    elif depth == "hobbies:music":
+        ignore = True
+
+    # Apply upper() and return the value
+    if not ignore and isinstance(value, str):
+        return value.upper()
+
+    return value
+```

deep_apply-1.0.0/README.md

@@ -0,0 +1,115 @@
+# Deep Apply
+
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/deep-apply?color=blue)](https://pypi.python.org/pypi/deep-apply)
+[![PyPI](https://img.shields.io/pypi/v/deep-apply?color=blue)](https://pypi.python.org/pypi/deep-apply)
+[![PyPI - License](https://img.shields.io/pypi/l/deep-apply)](https://pypi.python.org/pypi/deep-apply)
+
+[![tests](https://github.com/zaironjacobs/deep-apply/actions/workflows/test.yml/badge.svg)](https://github.com/zaironjacobs/deep-apply/actions/workflows/test.yml)
+
+Deep traverse through an object and apply a function on its values.
+
+Supports the following objects:
+
+* Dictionaries
+* Lists
+* Sets
+* Tuples
+* Pydantic models
+
+### Install
+
+```bash
+pip install deep-apply
+```
+
+### Usage
+
+#### Apply upper() on values
+
+```python
+import deep_apply
+
+
+# 1. Create your callback function. Will call upper() on strings.
+def to_upper(value, **kwargs):
+    """
+    To uppercase.
+    """
+
+    # Apply upper() and return the value
+    if isinstance(value, str):
+        return value.upper()
+
+    return value
+
+
+# 2. Your data.
+data = [
+    {
+        "id": "pZnZMffPCpJx",
+        "name": "John Doe",
+        "hobbies": {
+            "id": "OlVZysGsIywW",
+            "sport": ["football", "tennis"],
+            "music": ["singing", "guitar", "piano"],
+        },
+    }
+]
+
+# 3. Run apply()
+data = deep_apply.apply(data=data, func=to_upper)
+```
+
+#### Result
+
+```json
+[
+  {
+    "id": "PZNZMFFPCPJX",
+    "name": "JOHN DOE",
+    "hobbies": {
+      "id": "OLVZYSGSIYWW",
+      "sport": [
+        "FOOTBALL",
+        "TENNIS"
+      ],
+      "music": [
+        "SINGING",
+        "GUITAR",
+        "PIANO"
+      ]
+    }
+  }
+]
+```
+
+### Ignore keys
+
+You can get the current `key` or the current `depth` from `**kwargs` and add a condition e.g. to skip a specific key
+everywhere.
+
+```python
+def to_upper(value, **kwargs):
+    """
+    To uppercase.
+    """
+
+    key = kwargs.get("key")
+    depth = kwargs.get("depth")
+
+    ignore = False
+
+    # Ignore the key/field id everywhere (dictionaries or pydantic models)
+    if key == "id":
+        ignore = True
+
+    # Ignore the list of music found under hobbies
+    elif depth == "hobbies:music":
+        ignore = True
+
+    # Apply upper() and return the value
+    if not ignore and isinstance(value, str):
+        return value.upper()
+
+    return value
+```

deep_apply-1.0.0/deep_apply/__init__.py

@@ -0,0 +1 @@
+from deep_apply.deep_apply import apply

deep_apply-1.0.0/deep_apply/deep_apply.py

@@ -0,0 +1,66 @@
+import copy
+from typing import Callable, TypeVar
+
+from deep_apply import utils
+from deep_apply.handlers.handle_dict import handle_dict
+from deep_apply.handlers.handle_list import handle_list
+from deep_apply.handlers.handle_pydantic import handle_pydantic_model
+from deep_apply.handlers.handle_set import handle_set
+from deep_apply.handlers.handle_tuple import handle_tuple
+
+T = TypeVar("T")
+
+
+def __apply(
+    **kwargs,
+) -> T:
+    """
+    Apply.
+    """
+
+    data = kwargs["data"]
+    apply_func: Callable = kwargs["apply_func"]
+    key: str | None = kwargs.get("key")
+    depth: str | None = kwargs.get("depth")
+
+    if utils.is_list(data):
+        return handle_list(__apply, **kwargs)
+
+    elif utils.is_set(data):
+        return handle_set(__apply, **kwargs)
+
+    elif utils.is_tuple(data):
+        return handle_tuple(__apply, **kwargs)
+
+    elif utils.is_dict(data):
+        return handle_dict(__apply, **kwargs)
+
+    elif utils.is_pydantic_model(data):
+        return handle_pydantic_model(__apply, **kwargs)
+
+    else:
+        return apply_func(data, **{"key": key, "depth": depth})
+
+
+def apply(
+    data: T,
+    func: Callable,
+) -> T:
+    """
+    Deep traverse through an object and apply a function on its values.
+
+    Supports the following objects:
+     * Dictionaries
+     * Lists
+     * Sets
+     * Tuples
+     * Pydantic models
+
+    :param data: The data.
+    :param func: Function to apply on values.
+    """
+
+    return __apply(
+        data=copy.deepcopy(data),
+        apply_func=func,
+    )

deep_apply-1.0.0/deep_apply/exceptions.py

@@ -0,0 +1,2 @@
+class DeepApplyException(Exception):
+    pass

deep_apply-1.0.0/deep_apply/handlers/handle_dict.py

@@ -0,0 +1,22 @@
+from typing import Callable
+
+from deep_apply import utils
+
+
+def handle_dict(apply: Callable, **kwargs) -> dict:
+    """
+    Handle dict.
+    """
+
+    data = kwargs["data"]
+    depth: str | None = kwargs.get("depth")
+
+    for key, value in data.items():
+        kwargs["key"] = key
+        kwargs["data"] = value
+        kwargs["depth"] = utils.set_current_depth(key=key, depth=depth)
+        data[key] = apply(
+            **kwargs,
+        )
+
+    return data

deep_apply-1.0.0/deep_apply/handlers/handle_list.py

@@ -0,0 +1,17 @@
+from typing import Callable
+
+
+def handle_list(apply: Callable, **kwargs) -> list:
+    """
+    Handle list.
+    """
+
+    data = kwargs["data"]
+
+    for index, value in enumerate(data):
+        kwargs["data"] = value
+        data[index] = apply(
+            **kwargs,
+        )
+
+    return data

deep_apply-1.0.0/deep_apply/handlers/handle_pydantic.py

@@ -0,0 +1,28 @@
+from typing import Callable
+
+from pydantic import BaseModel
+
+from deep_apply import utils
+
+
+def handle_pydantic_model(apply: Callable, **kwargs) -> BaseModel:
+    """
+    Handle pydantic model.
+    """
+
+    data = kwargs["data"]
+    depth: str | None = kwargs.get("depth")
+
+    for key, value in iter(data):
+        kwargs["key"] = key
+        kwargs["data"] = value
+        kwargs["depth"] = utils.set_current_depth(key=key, depth=depth)
+        setattr(
+            data,
+            key,
+            apply(
+                **kwargs,
+            ),
+        )
+
+    return data

deep_apply-1.0.0/deep_apply/handlers/handle_set.py

@@ -0,0 +1,22 @@
+from typing import Callable
+
+
+def handle_set(apply: Callable, **kwargs) -> set:
+    """
+    Handle set.
+
+    The set values will not be modified with the apply function.
+    """
+
+    data = kwargs["data"]
+    data = list(data)
+
+    for index, value in enumerate(data):
+        kwargs["data"] = value
+        data[index] = apply(
+            **kwargs,
+        )
+
+    data = set(data)
+
+    return data

deep_apply-1.0.0/deep_apply/handlers/handle_tuple.py

@@ -0,0 +1,20 @@
+from typing import Callable
+
+
+def handle_tuple(apply: Callable, **kwargs) -> tuple:
+    """
+    Handle tuple.
+    """
+
+    data = kwargs["data"]
+    data = list(data)
+
+    for index, value in enumerate(data):
+        kwargs["data"] = value
+        data[index] = apply(
+            **kwargs,
+        )
+
+    data = tuple(data)
+
+    return data

deep_apply-1.0.0/deep_apply/utils.py

@@ -0,0 +1,56 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+
+def is_dict(data: Any) -> bool:
+    """
+    Check if data type is dict.
+    """
+
+    return isinstance(data, dict)
+
+
+def is_list(data: Any) -> bool:
+    """
+    Check if data type is list.
+    """
+
+    return isinstance(data, list)
+
+
+def is_set(data: Any) -> bool:
+    """
+    Check if data type is set.
+    """
+
+    return isinstance(data, set)
+
+
+def is_tuple(data: Any) -> bool:
+    """
+    Check if data type is tuple.
+    """
+
+    return isinstance(data, tuple)
+
+
+def is_pydantic_model(data: Any) -> bool:
+    """
+    Check if data is a pydantic model.
+    """
+
+    return isinstance(data, BaseModel)
+
+
+def set_current_depth(key: str, depth: str | None) -> str:
+    """
+    Set current depth.
+    """
+
+    if depth:
+        current_depth = f"{depth}:{key}"
+    else:
+        current_depth = key
+
+    return current_depth

deep_apply-1.0.0/deep_apply.egg-info/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.2
+Name: deep-apply
+Version: 1.0.0
+Summary: Deep traverse through an object and apply a function on its values.
+Home-page: https://github.com/zaironjacobs/deep-apply
+Download-URL: https://github.com/zaironjacobs/deep-apply/archive/v1.0.0.tar.gz
+Author: Zairon Jacobs
+Author-email: zaironjacobs@gmail.com
+License: MIT
+Keywords: deep,traverse,apply,object,list,set,tuple,pydantic,dict
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Natural Language :: English
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.4.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Deep Apply
+
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/deep-apply?color=blue)](https://pypi.python.org/pypi/deep-apply)
+[![PyPI](https://img.shields.io/pypi/v/deep-apply?color=blue)](https://pypi.python.org/pypi/deep-apply)
+[![PyPI - License](https://img.shields.io/pypi/l/deep-apply)](https://pypi.python.org/pypi/deep-apply)
+
+[![tests](https://github.com/zaironjacobs/deep-apply/actions/workflows/test.yml/badge.svg)](https://github.com/zaironjacobs/deep-apply/actions/workflows/test.yml)
+
+Deep traverse through an object and apply a function on its values.
+
+Supports the following objects:
+
+* Dictionaries
+* Lists
+* Sets
+* Tuples
+* Pydantic models
+
+### Install
+
+```bash
+pip install deep-apply
+```
+
+### Usage
+
+#### Apply upper() on values
+
+```python
+import deep_apply
+
+
+# 1. Create your callback function. Will call upper() on strings.
+def to_upper(value, **kwargs):
+    """
+    To uppercase.
+    """
+
+    # Apply upper() and return the value
+    if isinstance(value, str):
+        return value.upper()
+
+    return value
+
+
+# 2. Your data.
+data = [
+    {
+        "id": "pZnZMffPCpJx",
+        "name": "John Doe",
+        "hobbies": {
+            "id": "OlVZysGsIywW",
+            "sport": ["football", "tennis"],
+            "music": ["singing", "guitar", "piano"],
+        },
+    }
+]
+
+# 3. Run apply()
+data = deep_apply.apply(data=data, func=to_upper)
+```
+
+#### Result
+
+```json
+[
+  {
+    "id": "PZNZMFFPCPJX",
+    "name": "JOHN DOE",
+    "hobbies": {
+      "id": "OLVZYSGSIYWW",
+      "sport": [
+        "FOOTBALL",
+        "TENNIS"
+      ],
+      "music": [
+        "SINGING",
+        "GUITAR",
+        "PIANO"
+      ]
+    }
+  }
+]
+```
+
+### Ignore keys
+
+You can get the current `key` or the current `depth` from `**kwargs` and add a condition e.g. to skip a specific key
+everywhere.
+
+```python
+def to_upper(value, **kwargs):
+    """
+    To uppercase.
+    """
+
+    key = kwargs.get("key")
+    depth = kwargs.get("depth")
+
+    ignore = False
+
+    # Ignore the key/field id everywhere (dictionaries or pydantic models)
+    if key == "id":
+        ignore = True
+
+    # Ignore the list of music found under hobbies
+    elif depth == "hobbies:music":
+        ignore = True
+
+    # Apply upper() and return the value
+    if not ignore and isinstance(value, str):
+        return value.upper()
+
+    return value
+```

deep_apply-1.0.0/deep_apply.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+LICENSE
+README.md
+setup.cfg
+setup.py
+deep_apply/__init__.py
+deep_apply/deep_apply.py
+deep_apply/exceptions.py
+deep_apply/utils.py
+deep_apply.egg-info/PKG-INFO
+deep_apply.egg-info/SOURCES.txt
+deep_apply.egg-info/dependency_links.txt
+deep_apply.egg-info/requires.txt
+deep_apply.egg-info/top_level.txt
+deep_apply/handlers/__init__.py
+deep_apply/handlers/handle_dict.py
+deep_apply/handlers/handle_list.py
+deep_apply/handlers/handle_pydantic.py
+deep_apply/handlers/handle_set.py
+deep_apply/handlers/handle_tuple.py
+tests/__init__.py
+tests/test_dict.py
+tests/test_list.py
+tests/test_pydantic.py
+tests/test_set.py
+tests/test_tuple.py

deep_apply-1.0.0/deep_apply.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

deep_apply-1.0.0/deep_apply.egg-info/requires.txt

@@ -0,0 +1 @@
+pydantic>=2.4.0

deep_apply-1.0.0/deep_apply.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+deep_apply
+tests

deep_apply-1.0.0/setup.cfg

@@ -0,0 +1,8 @@
+[metadata]
+description-file = README.md
+long_description_content_type = text/markdown
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

deep_apply-1.0.0/setup.py

@@ -0,0 +1,48 @@
+from setuptools import setup
+from setuptools import find_packages
+
+name = "deep-apply"
+version = "1.0.0"
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+requires = ["pydantic>=2.4.0"]
+
+setup(
+    name=name,
+    version=version,
+    author="Zairon Jacobs",
+    author_email="zaironjacobs@gmail.com",
+    description=(
+        """
+        Deep traverse through an object and apply a function on its values.
+        """
+    ),
+    long_description=long_description,
+    url="https://github.com/zaironjacobs/deep-apply",
+    download_url=f"https://github.com/zaironjacobs/deep-apply/archive/v{version}.tar.gz",
+    keywords=[
+        "deep",
+        "traverse",
+        "apply",
+        "object",
+        "list",
+        "set",
+        "tuple",
+        "pydantic",
+        "dict",
+    ],
+    packages=find_packages(),
+    install_requires=requires,
+    license="MIT",
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3.11",
+        "Natural Language :: English",
+    ],
+    python_requires=">=3.11",
+)

deep_apply-1.0.0/tests/test_dict.py

@@ -0,0 +1,70 @@
+from pydantic import BaseModel
+
+from deep_apply import apply
+
+
+def my_func(value: str, **kwargs):
+    return value.upper()
+
+
+dict_test = {"first_name": "John", "last_name": "Doe"}
+
+
+def test_dict():
+    data = dict_test
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data["first_name"] == "JOHN" and data["last_name"] == "DOE"
+
+
+##########
+
+
+def test_dict_in_pydantic():
+    class Person(BaseModel):
+        nickname: dict[str, str]
+
+    person = Person(nickname={"nickname": "Johnnie"})
+
+    data = person
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data.nickname["nickname"] == "JOHNNIE"
+
+
+def test_dict_in_dict():
+    data = {"person": dict_test}
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert (
+        data["person"]["first_name"] == "JOHN" and data["person"]["last_name"] == "DOE"
+    )
+
+
+def test_dict_in_list():
+    data = [dict_test]
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data[0]["first_name"] == "JOHN" and data[0]["last_name"] == "DOE"
+
+
+def test_dict_in_tuple():
+    data = (dict_test, "dummy_data")
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data[0]["first_name"] == "JOHN" and data[0]["last_name"] == "DOE"

deep_apply-1.0.0/tests/test_list.py

@@ -0,0 +1,68 @@
+from pydantic import BaseModel
+
+from deep_apply import apply
+
+
+def my_func(value: str, **kwargs):
+    return value.upper()
+
+
+list_test = ["John Doe"]
+
+
+def test_list():
+    data = list_test
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data[0] == "JOHN DOE"
+
+
+##########
+
+
+def test_list_in_pydantic():
+    class Person(BaseModel):
+        nicknames: list[str]
+
+    person = Person(nicknames=["Johnnie", "Jo"])
+
+    data = person
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data.nicknames[0] == "JOHNNIE" and data.nicknames[1] == "JO"
+
+
+def test_list_in_dict():
+    data = {"person": list_test}
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data["person"][0] == "JOHN DOE"
+
+
+def test_list_in_list():
+    data = [list_test]
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data[0][0] == "JOHN DOE"
+
+
+def test_list_in_tuple():
+    data = (list_test, "dummy_data")
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data[0][0] == "JOHN DOE"

deep_apply-1.0.0/tests/test_pydantic.py

@@ -0,0 +1,76 @@
+from pydantic import BaseModel
+
+from deep_apply import apply
+
+
+def my_func(value: str, **kwargs):
+    return value.upper()
+
+
+class Person(BaseModel):
+    first_name: str
+    last_name: str
+
+
+class Child(Person):
+    pass
+
+
+class Parent(Person):
+    child: Child = Child(first_name="Jane", last_name="Doe")
+
+
+parent = Parent(first_name="John", last_name="Doe")
+
+
+def test_pydantic():
+    data = parent
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data.first_name == "JOHN" and data.last_name == "DOE"
+
+
+##########
+
+
+def test_pydantic_in_pydantic():
+    data = parent
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data.child.first_name == "JANE" and data.child.last_name == "DOE"
+
+
+def test_pydantic_in_dict():
+    data = {"person": parent}
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data["person"].first_name == "JOHN" and data["person"].last_name == "DOE"
+
+
+def test_pydantic_in_list():
+    data = [parent]
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data[0].first_name == "JOHN" and data[0].last_name == "DOE"
+
+
+def test_pydantic_in_tuple():
+    data = (parent, "dummy_data")
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data[0].first_name == "JOHN" and data[0].last_name == "DOE"

deep_apply-1.0.0/tests/test_set.py

@@ -0,0 +1,68 @@
+from pydantic import BaseModel
+
+from deep_apply import apply
+
+
+def my_func(value: str, **kwargs):
+    return value.upper()
+
+
+set_test: set[str] = {"John Doe"}
+
+
+def test_set():
+    data = set_test
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data.pop() == "JOHN DOE"
+
+
+##########
+
+
+def test_set_in_pydantic():
+    class Person(BaseModel):
+        nicknames: set[str]
+
+    pydantic = Person(nicknames={"Johnnie"})
+
+    data = pydantic
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data.nicknames.pop() == "JOHNNIE"
+
+
+def test_set_in_dict():
+    data = {"person": set_test}
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data["person"].pop() == "JOHN DOE"
+
+
+def test_set_in_list():
+    data = [set_test]
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data[0].pop() == "JOHN DOE"
+
+
+def test_set_in_tuple():
+    data = (set_test, "dummy_data")
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data[0].pop() == "JOHN DOE"

deep_apply-1.0.0/tests/test_tuple.py

@@ -0,0 +1,68 @@
+from pydantic import BaseModel
+
+from deep_apply import apply
+
+
+def my_func(value: str, **kwargs):
+    return value.upper()
+
+
+tuple_test: tuple[str, str] = ("John Doe", "Jane Doe")
+
+
+def test_tuple():
+    data = tuple_test
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data[0] == "JOHN DOE" and data[1] == "JANE DOE"
+
+
+##########
+
+
+def test_tuple_in_pydantic():
+    class Person(BaseModel):
+        nicknames: tuple[str, str]
+
+    person = Person(nicknames=("Johnnie", "Jo"))
+
+    data = person
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data.nicknames[0] == "JOHNNIE" and data.nicknames[1] == "JO"
+
+
+def test_tuple_in_dict():
+    data = {"person": tuple_test}
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data["person"][0] == "JOHN DOE" and data["person"][1] == "JANE DOE"
+
+
+def test_tuple_in_list():
+    data = [tuple_test]
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data[0][0] == "JOHN DOE" and data[0][1] == "JANE DOE"
+
+
+def test_tuple_in_tuple():
+    data = (tuple_test, "dummy_data")
+    data = apply(
+        data=data,
+        func=my_func,
+    )
+
+    assert data[0][0] == "JOHN DOE" and data[0][1] == "JANE DOE"