diffsync 1.9.0__tar.gz → 2.0.0__tar.gz

{diffsync-1.9.0 → diffsync-2.0.0}/CHANGELOG.md

@@ -1,6 +1,27 @@
 # Changelog
 
-## v1.9.0 - 2023-10-16
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [2.0.0]
+
+### Changed
+
+- **BREAKING CHANGE** #236/240 - Upgrade to Pydantic v2. 
+
+## [1.10.0] - 2023-11-16
+
+### Fixed
+
+- #249 - Fixes natural deletion order flag
+- #247 - Fixes underspecified typing_extensions dependency
+
+### Changed
+
+- #247 - Deprecates Python 3.7
+
+## [1.9.0] - 2023-10-16
 
 ### Added
 
@@ -10,7 +31,7 @@
 
 - #219 - Type hinting overhaul 
 
-## v1.8.0 - 2023-04-18
+## [1.8.0] - 2023-04-18
 
 ### Added
 
@@ -23,7 +44,7 @@
 - #77/#188 - `sync_from()` and `sync_to()` now return the `Diff` that was applied.
 - #211 - Loosened `packaging` and `structlog` library dependency constraints for broader compatibility.
 
-## v1.7.0 - 2022-11-03
+## [1.7.0] - 2022-11-03
 
 ### Changed
 
@@ -41,15 +62,15 @@
 
 ### Fixed
 
-- #149 Limit redundant CI concurrency
+- #149 - Limit redundant CI concurrency
 
-## v1.6.0 - 2022-07-09
+## [1.6.0] - 2022-07-09
 
 ### Changed
 
 - #120 - Dropped support for Python 3.6, new minimum is Python 3.7
 
-## v1.5.1 - 2022-06-30
+## [1.5.1] - 2022-06-30
 
 ### Added
 
@@ -64,13 +85,13 @@
 - #115 - Fixed ReadTheDocs rendering pipeline
 - #118 - Fixed a regression in `DiffSync.get(modelname, identifiers)` introduced in 1.5.0
 
-## v1.5.0 - 2022-06-07
+## [1.5.0] - 2022-06-07
 
 ### Added
 
 - #106 - Add a new, optional, backend store based in Redis
 
-## v1.4.3 - 2022-03-03
+## [1.4.3] - 2022-03-03
 
 ### Fixed
 
@@ -80,9 +101,9 @@
 
 ### Changed
 
-- #103 Update development dependencies
+- #103 - Update development dependencies
 
-## v1.4.2 - 2022-02-28
+## [1.4.2] - 2022-02-28
 
 **WARNING** - #90 inadvertently introduced a breaking API change in DiffSync 1.4.0 through 1.4.2 (#101); this change was reverted in #102 for DiffSync 1.4.3 and later. We recommend not using this release, and moving to 1.4.3 instead.
 
@@ -90,7 +111,7 @@
 
 - #100 - Added explicit dependency on `packaging`.
 
-## v1.4.1 - 2022-01-26
+## [1.4.1] - 2022-01-26
 
 **WARNING** - #90 inadvertently introduced a breaking API change in DiffSync 1.4.0 through 1.4.2 (#101); this change was reverted in #102 for DiffSync 1.4.3 and later. We recommend not using this release, and moving to 1.4.3 instead.
 
@@ -98,7 +119,7 @@
 
 - #95 - Removed optional dependencies on `sphinx`, `m2r2`, `sphinx-rtd-theme`, `toml`.
 
-## v1.4.0 - 2022-01-24
+## [1.4.0] - 2022-01-24
 
 **WARNING** - #90 inadvertently introduced a breaking API change in DiffSync 1.4.0 through 1.4.2 (#101); this change was reverted in #102 for DiffSync 1.4.3 and later. We recommend not using this release, and moving to 1.4.3 instead.
 
@@ -127,19 +148,19 @@
 - #51 - Update minimum Pydantic version due to security advisory GHSA-5jqp-qgf6-3pvh
 - #63 - Fix type in Readme
 
-## v1.3.0 - 2021-04-07
+## [1.3.0] - 2021-04-07
 
 ### Added
 
 - #48 - added optional `callback` argument to `diff_from`/`diff_to`/`sync_from`/`sync_to` for use with progress reporting.
 
-## v1.2.0 - 2020-12-08
+## [1.2.0] - 2020-12-08
 
 ### Added
 
 - #45 - minimum Python version lowered from 3.7 to 3.6, also now tested against Python 3.9.
 
-## v1.1.0 - 2020-12-01
+## [1.1.0] - 2020-12-01
 
 ### Added
 
@@ -157,6 +178,6 @@
 
 - #44 - On CRUD failure, do not generate an extraneous "success" log message in addition to the "failed" message
 
-## v1.0.0 - 2020-10-23
+## [1.0.0] - 2020-10-23
 
 Initial release

{diffsync-1.9.0 → diffsync-2.0.0}/PKG-INFO

@@ -1,26 +1,27 @@
 Metadata-Version: 2.1
 Name: diffsync
-Version: 1.9.0
+Version: 2.0.0
 Summary: Library to easily sync/diff/update 2 different data sources
 Home-page: https://diffsync.readthedocs.io
 License: Apache-2.0
 Keywords: source-of-truth,synchronization
 Author: Network to Code, LLC
 Author-email: info@networktocode.com
-Requires-Python: >=3.7,<4.0
+Requires-Python: >=3.8,<4.0
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: redis
 Requires-Dist: colorama (>=0.4.3,<0.5.0)
 Requires-Dist: packaging (>=21.3,<24.0)
-Requires-Dist: pydantic (>=1.7.4,<2.0.0,!=1.8,!=1.8.1)
+Requires-Dist: pydantic (>=2.0.0,<3.0.0)
 Requires-Dist: redis (>=4.3,<5.0) ; extra == "redis"
 Requires-Dist: structlog (>=20.1.0,<23.0.0)
+Requires-Dist: typing-extensions (>=4.0.1) ; python_version < "3.11"
 Project-URL: Documentation, https://diffsync.readthedocs.io
 Project-URL: Repository, https://github.com/networktocode/diffsync
 Description-Content-Type: text/markdown
@@ -42,7 +43,7 @@ DiffSync is at its most useful when you have multiple sources or sets of data to
 
 # Overview of DiffSync
 
-DiffSync acts as an intermediate translation layer between all of the data sets you are diffing and/or syncing. In practical terms, this means that to use DiffSync, you will define a set of data models as well as the “adapters” needed to translate between each base data source and the data model. In Python terms, the adapters will be subclasses of the `DiffSync` class, and each data model class will be a subclass of the `DiffSyncModel` class.
+DiffSync acts as an intermediate translation layer between all of the data sets you are diffing and/or syncing. In practical terms, this means that to use DiffSync, you will define a set of data models as well as the “adapters” needed to translate between each base data source and the data model. In Python terms, the adapters will be subclasses of the `Adapter` class, and each data model class will be a subclass of the `DiffSyncModel` class.
 
 ![Diffsync Components](https://raw.githubusercontent.com/networktocode/diffsync/develop/docs/images/diffsync_components.png "Diffsync Components")
 

{diffsync-1.9.0 → diffsync-2.0.0}/README.md

@@ -15,7 +15,7 @@ DiffSync is at its most useful when you have multiple sources or sets of data to
 
 # Overview of DiffSync
 
-DiffSync acts as an intermediate translation layer between all of the data sets you are diffing and/or syncing. In practical terms, this means that to use DiffSync, you will define a set of data models as well as the “adapters” needed to translate between each base data source and the data model. In Python terms, the adapters will be subclasses of the `DiffSync` class, and each data model class will be a subclass of the `DiffSyncModel` class.
+DiffSync acts as an intermediate translation layer between all of the data sets you are diffing and/or syncing. In practical terms, this means that to use DiffSync, you will define a set of data models as well as the “adapters” needed to translate between each base data source and the data model. In Python terms, the adapters will be subclasses of the `Adapter` class, and each data model class will be a subclass of the `DiffSyncModel` class.
 
 ![Diffsync Components](https://raw.githubusercontent.com/networktocode/diffsync/develop/docs/images/diffsync_components.png "Diffsync Components")
 

{diffsync-1.9.0 → diffsync-2.0.0}/diffsync/__init__.py

@@ -14,21 +14,43 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 """
+import sys
 from inspect import isclass
-from typing import Callable, ClassVar, Dict, List, Optional, Tuple, Type, Union, Any, Set
-from typing_extensions import Self
-
-from pydantic import BaseModel, PrivateAttr
+from typing import (
+    Callable,
+    ClassVar,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+    Any,
+    Set,
+)
+import warnings
+
+from pydantic import ConfigDict, BaseModel, PrivateAttr
 import structlog  # type: ignore
 
 from diffsync.diff import Diff
 from diffsync.enum import DiffSyncModelFlags, DiffSyncFlags, DiffSyncStatus
-from diffsync.exceptions import DiffClassMismatch, ObjectAlreadyExists, ObjectStoreWrongType, ObjectNotFound
+from diffsync.exceptions import (
+    DiffClassMismatch,
+    ObjectAlreadyExists,
+    ObjectStoreWrongType,
+    ObjectNotFound,
+)
 from diffsync.helpers import DiffSyncDiffer, DiffSyncSyncer
 from diffsync.store import BaseStore
 from diffsync.store.local import LocalStore
 from diffsync.utils import get_path, set_key, tree_string
 
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
 # This workaround is used because we are defining a method called `str` in our class definition, which therefore renders
 # the builtin `str` type unusable.
 StrType = str
@@ -91,8 +113,8 @@ class DiffSyncModel(BaseModel):
     Can be set as a class attribute or an instance attribute as needed.
     """
 
-    diffsync: Optional["DiffSync"] = None
-    """Optional: the DiffSync instance that owns this model instance."""
+    adapter: Optional["Adapter"] = None
+    """Optional: the Adapter instance that owns this model instance."""
 
     _status: DiffSyncStatus = PrivateAttr(DiffSyncStatus.SUCCESS)
     """Status of the last attempt at creating/updating/deleting this model."""
@@ -100,30 +122,27 @@ class DiffSyncModel(BaseModel):
     _status_message: str = PrivateAttr("")
     """Message, if any, associated with the create/update/delete status value."""
 
-    class Config:  # pylint: disable=too-few-public-methods
-        """Pydantic class configuration."""
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    """Pydantic-specific configuration to allow arbitrary types on this class."""
 
-        # Let us have a DiffSync as an instance variable even though DiffSync is not a Pydantic model itself.
-        arbitrary_types_allowed = True
-
-    def __init_subclass__(cls) -> None:
+    @classmethod
+    def __pydantic_init_subclass__(cls, **kwargs: Any) -> None:
         """Validate that the various class attribute declarations correspond to actual instance fields.
 
         Called automatically on subclass declaration.
         """
-        variables = cls.__fields__.keys()
         # Make sure that any field referenced by name actually exists on the model
         for attr in cls._identifiers:
-            if attr not in variables and not hasattr(cls, attr):
+            if attr not in cls.model_fields and not hasattr(cls, attr):
                 raise AttributeError(f"_identifiers {cls._identifiers} references missing or un-annotated attr {attr}")
         for attr in cls._shortname:
-            if attr not in variables:
+            if attr not in cls.model_fields:
                 raise AttributeError(f"_shortname {cls._shortname} references missing or un-annotated attr {attr}")
         for attr in cls._attributes:
-            if attr not in variables:
+            if attr not in cls.model_fields:
                 raise AttributeError(f"_attributes {cls._attributes} references missing or un-annotated attr {attr}")
         for attr in cls._children.values():
-            if attr not in variables:
+            if attr not in cls.model_fields:
                 raise AttributeError(f"_children {cls._children} references missing or un-annotated attr {attr}")
 
         # Any given field can only be in one of (_identifiers, _attributes, _children)
@@ -144,18 +163,18 @@ class DiffSyncModel(BaseModel):
         return self.get_unique_id()
 
     def dict(self, **kwargs: Any) -> Dict:
-        """Convert this DiffSyncModel to a dict, excluding the diffsync field by default as it is not serializable."""
+        """Convert this DiffSyncModel to a dict, excluding the adapter field by default as it is not serializable."""
         if "exclude" not in kwargs:
-            kwargs["exclude"] = {"diffsync"}
-        return super().dict(**kwargs)
+            kwargs["exclude"] = {"adapter"}
+        return super().model_dump(**kwargs)
 
     def json(self, **kwargs: Any) -> StrType:
-        """Convert this DiffSyncModel to a JSON string, excluding the diffsync field by default as it is not serializable."""
+        """Convert this DiffSyncModel to a JSON string, excluding the adapter field by default as it is not serializable."""
         if "exclude" not in kwargs:
-            kwargs["exclude"] = {"diffsync"}
+            kwargs["exclude"] = {"adapter"}
         if "exclude_defaults" not in kwargs:
             kwargs["exclude_defaults"] = True
-        return super().json(**kwargs)
+        return super().model_dump_json(**kwargs)
 
     def str(self, include_children: bool = True, indent: int = 0) -> StrType:
         """Build a detailed string representation of this DiffSyncModel and optionally its children."""
@@ -166,12 +185,12 @@ class DiffSyncModel(BaseModel):
             child_ids = getattr(self, fieldname)
             if not child_ids:
                 output += ": []"
-            elif not self.diffsync or not include_children:
+            elif not self.adapter or not include_children:
                 output += f": {child_ids}"
             else:
                 for child_id in child_ids:
                     try:
-                        child = self.diffsync.get(modelname, child_id)
+                        child = self.adapter.get(modelname, child_id)
                         output += "\n" + child.str(include_children=include_children, indent=indent + 4)
                     except ObjectNotFound:
                         output += f"\n{margin}    {child_id} (ERROR: details unavailable)"
@@ -183,32 +202,32 @@ class DiffSyncModel(BaseModel):
         self._status_message = message
 
     @classmethod
-    def create_base(cls, diffsync: "DiffSync", ids: Dict, attrs: Dict) -> Optional[Self]:
+    def create_base(cls, adapter: "Adapter", ids: Dict, attrs: Dict) -> Optional[Self]:
         """Instantiate this class, along with any platform-specific data creation.
 
         This method is not meant to be subclassed, users should redefine create() instead.
 
         Args:
-            diffsync: The master data store for other DiffSyncModel instances that we might need to reference
+            adapter: The master data store for other DiffSyncModel instances that we might need to reference
             ids: Dictionary of unique-identifiers needed to create the new object
             attrs: Dictionary of additional attributes to set on the new object
 
         Returns:
             DiffSyncModel: instance of this class.
         """
-        model = cls(**ids, diffsync=diffsync, **attrs)
+        model = cls(**ids, adapter=adapter, **attrs)
         model.set_status(DiffSyncStatus.SUCCESS, "Created successfully")
         return model
 
     @classmethod
-    def create(cls, diffsync: "DiffSync", ids: Dict, attrs: Dict) -> Optional[Self]:
+    def create(cls, adapter: "Adapter", ids: Dict, attrs: Dict) -> Optional[Self]:
         """Instantiate this class, along with any platform-specific data creation.
 
         Subclasses must call `super().create()` or `self.create_base()`; they may wish to then override the default status information
         by calling `set_status()` to provide more context (such as details of any interactions with underlying systems).
 
         Args:
-            diffsync: The master data store for other DiffSyncModel instances that we might need to reference
+            adapter: The master data store for other DiffSyncModel instances that we might need to reference
             ids: Dictionary of unique-identifiers needed to create the new object
             attrs: Dictionary of additional attributes to set on the new object
 
@@ -219,7 +238,7 @@ class DiffSyncModel(BaseModel):
         Raises:
             ObjectNotCreated: if an error occurred.
         """
-        return cls.create_base(diffsync=diffsync, ids=ids, attrs=attrs)
+        return cls.create_base(adapter=adapter, ids=ids, attrs=attrs)
 
     def update_base(self, attrs: Dict) -> Optional[Self]:
         """Base Update method to update the attributes of this instance, along with any platform-specific data updates.
@@ -375,7 +394,10 @@ class DiffSyncModel(BaseModel):
         attr_name = self._children[child_type]
         childs = getattr(self, attr_name)
         if child.get_unique_id() in childs:
-            raise ObjectAlreadyExists(f"Already storing a {child_type} with unique_id {child.get_unique_id()}", child)
+            raise ObjectAlreadyExists(
+                f"Already storing a {child_type} with unique_id {child.get_unique_id()}",
+                child,
+            )
         childs.append(child.get_unique_id())
 
     def remove_child(self, child: "DiffSyncModel") -> None:
@@ -402,7 +424,7 @@ class DiffSyncModel(BaseModel):
         childs.remove(child.get_unique_id())
 
 
-class DiffSync:  # pylint: disable=too-many-public-methods
+class Adapter:  # pylint: disable=too-many-public-methods
     """Class for storing a group of DiffSyncModel instances and diffing/synchronizing to another DiffSync instance."""
 
     # In any subclass, you would add mapping of names to specific model classes here:
@@ -416,7 +438,9 @@ class DiffSync:  # pylint: disable=too-many-public-methods
     """List of top-level modelnames to begin from when diffing or synchronizing."""
 
     def __init__(
-        self, name: Optional[str] = None, internal_storage_engine: Union[Type[BaseStore], BaseStore] = LocalStore
+        self,
+        name: Optional[str] = None,
+        internal_storage_engine: Union[Type[BaseStore], BaseStore] = LocalStore,
     ) -> None:
         """Generic initialization function.
 
@@ -425,9 +449,9 @@ class DiffSync:  # pylint: disable=too-many-public-methods
 
         if isinstance(internal_storage_engine, BaseStore):
             self.store = internal_storage_engine
-            self.store.diffsync = self
+            self.store.adapter = self
         else:
-            self.store = internal_storage_engine(diffsync=self)
+            self.store = internal_storage_engine(adapter=self)
 
         # If the type is not defined, use the name of the class as the default value
         if self.type is None:
@@ -535,7 +559,7 @@ class DiffSync:  # pylint: disable=too-many-public-methods
 
     def sync_from(  # pylint: disable=too-many-arguments
         self,
-        source: "DiffSync",
+        source: "Adapter",
         diff_class: Type[Diff] = Diff,
         flags: DiffSyncFlags = DiffSyncFlags.NONE,
         callback: Optional[Callable[[StrType, int, int], None]] = None,
@@ -564,7 +588,13 @@ class DiffSync:  # pylint: disable=too-many-public-methods
         # Generate the diff if an existing diff was not provided
         if not diff:
             diff = self.diff_from(source, diff_class=diff_class, flags=flags, callback=callback)
-        syncer = DiffSyncSyncer(diff=diff, src_diffsync=source, dst_diffsync=self, flags=flags, callback=callback)
+        syncer = DiffSyncSyncer(
+            diff=diff,
+            src_diffsync=source,
+            dst_diffsync=self,
+            flags=flags,
+            callback=callback,
+        )
         result = syncer.perform_sync()
         if result:
             self.sync_complete(source, diff, flags, syncer.base_logger)
@@ -573,7 +603,7 @@ class DiffSync:  # pylint: disable=too-many-public-methods
 
     def sync_to(  # pylint: disable=too-many-arguments
         self,
-        target: "DiffSync",
+        target: "Adapter",
         diff_class: Type[Diff] = Diff,
         flags: DiffSyncFlags = DiffSyncFlags.NONE,
         callback: Optional[Callable[[StrType, int, int], None]] = None,
@@ -597,7 +627,7 @@ class DiffSync:  # pylint: disable=too-many-public-methods
 
     def sync_complete(
         self,
-        source: "DiffSync",
+        source: "Adapter",
         diff: Diff,
         flags: DiffSyncFlags = DiffSyncFlags.NONE,
         logger: Optional[structlog.BoundLogger] = None,
@@ -623,7 +653,7 @@ class DiffSync:  # pylint: disable=too-many-public-methods
 
     def diff_from(
         self,
-        source: "DiffSync",
+        source: "Adapter",
         diff_class: Type[Diff] = Diff,
         flags: DiffSyncFlags = DiffSyncFlags.NONE,
         callback: Optional[Callable[[StrType, int, int], None]] = None,
@@ -638,13 +668,17 @@ class DiffSync:  # pylint: disable=too-many-public-methods
                 calculation of the diff proceeds.
         """
         differ = DiffSyncDiffer(
-            src_diffsync=source, dst_diffsync=self, flags=flags, diff_class=diff_class, callback=callback
+            src_diffsync=source,
+            dst_diffsync=self,
+            flags=flags,
+            diff_class=diff_class,
+            callback=callback,
         )
         return differ.calculate_diffs()
 
     def diff_to(
         self,
-        target: "DiffSync",
+        target: "Adapter",
         diff_class: Type[Diff] = Diff,
         flags: DiffSyncFlags = DiffSyncFlags.NONE,
         callback: Optional[Callable[[StrType, int, int], None]] = None,
@@ -673,7 +707,9 @@ class DiffSync:  # pylint: disable=too-many-public-methods
         return self.store.get_all_model_names()
 
     def get(
-        self, obj: Union[StrType, DiffSyncModel, Type[DiffSyncModel]], identifier: Union[StrType, Dict]
+        self,
+        obj: Union[StrType, DiffSyncModel, Type[DiffSyncModel]],
+        identifier: Union[StrType, Dict],
     ) -> DiffSyncModel:
         """Get one object from the data store based on its unique id.
 
@@ -688,7 +724,9 @@ class DiffSync:  # pylint: disable=too-many-public-methods
         return self.store.get(model=obj, identifier=identifier)
 
     def get_or_none(
-        self, obj: Union[StrType, DiffSyncModel, Type[DiffSyncModel]], identifier: Union[StrType, Dict]
+        self,
+        obj: Union[StrType, DiffSyncModel, Type[DiffSyncModel]],
+        identifier: Union[StrType, Dict],
     ) -> Optional[DiffSyncModel]:
         """Get one object from the data store based on its unique id or get a None
 
@@ -719,7 +757,9 @@ class DiffSync:  # pylint: disable=too-many-public-methods
         return self.store.get_all(model=obj)
 
     def get_by_uids(
-        self, uids: List[StrType], obj: Union[StrType, DiffSyncModel, Type[DiffSyncModel]]
+        self,
+        uids: List[StrType],
+        obj: Union[StrType, DiffSyncModel, Type[DiffSyncModel]],
     ) -> List[DiffSyncModel]:
         """Get multiple objects from the store by their unique IDs/Keys and type.
 
@@ -854,5 +894,15 @@ class DiffSync:  # pylint: disable=too-many-public-methods
         return self.store.count(model=model)
 
 
-# DiffSyncModel references DiffSync and DiffSync references DiffSyncModel. Break the typing loop:
-DiffSyncModel.update_forward_refs()
+def DiffSync(*args: Any, **kwargs: Any) -> Adapter:  # noqa  pylint: disable=invalid-name
+    """For backwards-compatibility, keep around the old name."""
+
+    warnings.warn(
+        "'diffsync.DiffSync' is deprecated and will be removed with 2.1, use 'diffsync.Adapter' instead.",
+        DeprecationWarning,
+    )
+    return Adapter(*args, **kwargs)
+
+
+# DiffSyncModel references Adapter and Adapter references DiffSyncModel. Break the typing loop:
+DiffSyncModel.model_rebuild()

{diffsync-1.9.0 → diffsync-2.0.0}/diffsync/helpers.py

@@ -26,7 +26,7 @@ from .utils import intersection, symmetric_difference
 
 if TYPE_CHECKING:  # pragma: no cover
     # For type annotation purposes, we have a circular import loop between __init__.py and this file.
-    from . import DiffSync, DiffSyncModel  # pylint: disable=cyclic-import
+    from . import Adapter, DiffSyncModel  # pylint: disable=cyclic-import
 
 
 class DiffSyncDiffer:  # pylint: disable=too-many-instance-attributes
@@ -37,8 +37,8 @@ class DiffSyncDiffer:  # pylint: disable=too-many-instance-attributes
 
     def __init__(  # pylint: disable=too-many-arguments
         self,
-        src_diffsync: "DiffSync",
-        dst_diffsync: "DiffSync",
+        src_diffsync: "Adapter",
+        dst_diffsync: "Adapter",
         flags: DiffSyncFlags,
         diff_class: Type[Diff] = Diff,
         callback: Optional[Callable[[str, int, int], None]] = None,
@@ -288,8 +288,8 @@ class DiffSyncSyncer:  # pylint: disable=too-many-instance-attributes
     def __init__(  # pylint: disable=too-many-arguments
         self,
         diff: Diff,
-        src_diffsync: "DiffSync",
-        dst_diffsync: "DiffSync",
+        src_diffsync: "Adapter",
+        dst_diffsync: "Adapter",
         flags: DiffSyncFlags,
         callback: Optional[Callable[[str, int, int], None]] = None,
     ):
@@ -369,11 +369,13 @@ class DiffSyncSyncer:  # pylint: disable=too-many-instance-attributes
             natural_deletion_order = bool(dst_model.model_flags & DiffSyncModelFlags.NATURAL_DELETION_ORDER)
             skip_children = bool(dst_model.model_flags & DiffSyncModelFlags.SKIP_CHILDREN_ON_DELETE)
 
+        # Recurse through children to delete if we are supposed to delete the current diff element
         changed = False
         if natural_deletion_order and self.action == DiffSyncActions.DELETE and not skip_children:
             for child in element.get_children():
                 changed |= self.sync_diff_element(child, parent_model=dst_model)
 
+        # Sync the current model - this will delete the current model if self.action is DELETE
         changed, modified_model = self.sync_model(src_model=src_model, dst_model=dst_model, ids=ids, attrs=attrs)
         dst_model = modified_model or dst_model
 
@@ -396,7 +398,7 @@ class DiffSyncSyncer:  # pylint: disable=too-many-instance-attributes
 
         self.incr_elements_processed()
 
-        if not natural_deletion_order:
+        if not natural_deletion_order or self.action is not DiffSyncActions.DELETE:
             for child in element.get_children():
                 changed |= self.sync_diff_element(child, parent_model=dst_model)
 
@@ -423,7 +425,7 @@ class DiffSyncSyncer:  # pylint: disable=too-many-instance-attributes
             if self.action == DiffSyncActions.CREATE:
                 if dst_model is not None:
                     raise ObjectNotCreated(f"Failed to create {self.model_class.get_type()} {ids} - it already exists!")
-                dst_model = self.model_class.create(diffsync=self.dst_diffsync, ids=ids, attrs=attrs)
+                dst_model = self.model_class.create(adapter=self.dst_diffsync, ids=ids, attrs=attrs)
             elif self.action == DiffSyncActions.UPDATE:
                 if dst_model is None:
                     raise ObjectNotUpdated(f"Failed to update {self.model_class.get_type()} {ids} - not found!")

{diffsync-1.9.0 → diffsync-2.0.0}/diffsync/store/__init__.py

@@ -6,7 +6,7 @@ from diffsync.exceptions import ObjectNotFound
 
 if TYPE_CHECKING:
     from diffsync import DiffSyncModel
-    from diffsync import DiffSync
+    from diffsync import Adapter
 
 
 class BaseStore:
@@ -15,12 +15,12 @@ class BaseStore:
     def __init__(
         self,  # pylint: disable=unused-argument
         *args: Any,  # pylint: disable=unused-argument
-        diffsync: Optional["DiffSync"] = None,
+        adapter: Optional["Adapter"] = None,
         name: str = "",
         **kwargs: Any,  # pylint: disable=unused-argument
     ) -> None:
         """Init method for BaseStore."""
-        self.diffsync = diffsync
+        self.adapter = adapter
         self.name = name or self.__class__.__name__
         self._log = structlog.get_logger().new(store=self)
 
@@ -95,8 +95,8 @@ class BaseStore:
 
         self.remove_item(modelname, uid)
 
-        if obj.diffsync:
-            obj.diffsync = None
+        if obj.adapter:
+            obj.adapter = None
 
         if remove_children:
             for child_type, child_fieldname in obj.get_children_mapping().items():
@@ -243,9 +243,9 @@ class BaseStore:
         """Get object class and model name for a model."""
         if isinstance(model, str):
             modelname = model
-            if not hasattr(self.diffsync, model):
+            if not hasattr(self.adapter, model):
                 return None, modelname
-            object_class = getattr(self.diffsync, model)
+            object_class = getattr(self.adapter, model)
         else:
             object_class = model
             modelname = model.get_type()

{diffsync-1.9.0 → diffsync-2.0.0}/diffsync/store/local.py

@@ -108,8 +108,8 @@ class LocalStore(BaseStore):
             # Return so we don't have to change anything on the existing object and underlying data
             return
 
-        if not obj.diffsync:
-            obj.diffsync = self.diffsync
+        if not obj.adapter:
+            obj.adapter = self.adapter
 
         self._data[modelname][uid] = obj
 

{diffsync-1.9.0 → diffsync-2.0.0}/diffsync/store/redis.py

@@ -65,7 +65,7 @@ class RedisStore(BaseStore):
         pickled_object = self._store.get(key)
         if pickled_object:
             obj_result = loads(pickled_object)  # nosec
-            obj_result.diffsync = self.diffsync
+            obj_result.adapter = self.adapter
             return obj_result
         raise ObjectNotFound(f"{key} not present in Cache")
 
@@ -178,7 +178,7 @@ class RedisStore(BaseStore):
 
         # Remove the diffsync object before sending to Redis
         obj_copy = copy.copy(obj)
-        obj_copy.diffsync = None
+        obj_copy.adapter = None
 
         self._store.set(object_key, dumps(obj_copy))
 
@@ -193,7 +193,7 @@ class RedisStore(BaseStore):
 
         object_key = self._get_key_for_object(modelname, uid)
         obj_copy = copy.copy(obj)
-        obj_copy.diffsync = None
+        obj_copy.adapter = None
 
         self._store.set(object_key, dumps(obj_copy))
 

{diffsync-1.9.0 → diffsync-2.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "diffsync"
-version = "v1.9.0"
+version = "v2.0.0"
 description = "Library to easily sync/diff/update 2 different data sources"
 authors = ["Network to Code, LLC <info@networktocode.com>"]
 license = "Apache-2.0"
@@ -16,12 +16,14 @@ include = [
 ]
 
 [tool.poetry.dependencies]
-python = "^3.7"
-pydantic = "^1.7.4,!=1.8,!=1.8.1"
+python = ">=3.8,<4.0"
+pydantic = "^2.0.0"
 structlog = ">= 20.1.0, < 23.0.0"
 packaging = ">= 21.3, < 24.0"
 colorama = {version = "^0.4.3", optional = true}
 redis = {version = "^4.3", optional = true}
+# typing.Self introduced in 3.11
+typing-extensions = { version = ">=4.0.1", python = "<3.11" }
 
 [tool.poetry.extras]
 redis = ["redis"]