diffsync 2.0.0__tar.gz → 2.1.0__tar.gz

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

@@ -4,6 +4,35 @@ 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.1.0]
+
+### Changed
+
+- [284](https://github.com/networktocode/diffsync/pull/284) - Update pyyaml to 6.0.2 in poetry.lock by @gsnider2195
+- [286](https://github.com/networktocode/diffsync/pull/286) - Update GitHub Actions runner version by @mjbear
+- [289](https://github.com/networktocode/diffsync/pull/289) - Remove upper limit on Packaging by @jdrew82
+
+## New Contributors
+
+- @gsnider2195 made their first contribution in https://github.com/networktocode/diffsync/pull/284
+- @mjbear made their first contribution in https://github.com/networktocode/diffsync/pull/286
+- @jdrew82 made their first contribution in https://github.com/networktocode/diffsync/pull/289
+
+## [2.0.1]
+
+### Changed
+
+- #276 - Removed upper version bound for `structlog` dependency
+
+### Fixed
+
+- #281 - Properly deprecated `DiffSync` class name
+- #273 - Properly capitalized `DiffSync` in documentation
+- #273 - Removed more mentions of `DiffSync` in favor of `Adapter`
+- #274 - Fixed doc section title for getting started
+- #269 - Fixed wording for a couple of docstrings
+- #265 - Fixed readthedocs build
+
 ## [2.0.0]
 
 ### Changed

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

@@ -1,28 +1,27 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: diffsync
-Version: 2.0.0
+Version: 2.1.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.8,<4.0
+Requires-Python: >=3.9,<4.0
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-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
+Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: redis
-Requires-Dist: colorama (>=0.4.3,<0.5.0)
-Requires-Dist: packaging (>=21.3,<24.0)
+Requires-Dist: packaging (>=21.3)
 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: structlog (>=20.1.0)
 Requires-Dist: typing-extensions (>=4.0.1) ; python_version < "3.11"
 Project-URL: Documentation, https://diffsync.readthedocs.io
+Project-URL: Homepage, https://diffsync.readthedocs.io
 Project-URL: Repository, https://github.com/networktocode/diffsync
 Description-Content-Type: text/markdown
 
@@ -45,16 +44,16 @@ DiffSync is at its most useful when you have multiple sources or sets of data to
 
 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 Components](https://raw.githubusercontent.com/networktocode/diffsync/develop/docs/images/diffsync_components.png "DiffSync Components")
 
 
 Once you have used each adapter to load each data source into a collection of data model records, you can then ask DiffSync to “diff” the two data sets, and it will produce a structured representation of the difference between them. In Python, this is accomplished by calling the `diff_to()` or `diff_from()` method on one adapter and passing the other adapter as a parameter.
 
-![Diffsync Diff Creation](https://raw.githubusercontent.com/networktocode/diffsync/develop/docs/images/diffsync_diff_creation.png "Diffsync Diff Creation")
+![DiffSync Diff Creation](https://raw.githubusercontent.com/networktocode/diffsync/develop/docs/images/diffsync_diff_creation.png "DiffSync Diff Creation")
 
 You can also ask DiffSync to “sync” one data set onto the other, and it will instruct your adapter as to the steps it needs to take to make sure that its data set accurately reflects the other. In Python, this is accomplished by calling the `sync_to()` or `sync_from()` method on one adapter and passing the other adapter as a parameter.
 
-![Diffsync Sync](https://raw.githubusercontent.com/networktocode/diffsync/develop/docs/images/diffsync_sync.png "Diffsync Sync")
+![DiffSync Sync](https://raw.githubusercontent.com/networktocode/diffsync/develop/docs/images/diffsync_sync.png "DiffSync Sync")
 
 # Simple Example
 

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

@@ -17,16 +17,16 @@ DiffSync is at its most useful when you have multiple sources or sets of data to
 
 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 Components](https://raw.githubusercontent.com/networktocode/diffsync/develop/docs/images/diffsync_components.png "DiffSync Components")
 
 
 Once you have used each adapter to load each data source into a collection of data model records, you can then ask DiffSync to “diff” the two data sets, and it will produce a structured representation of the difference between them. In Python, this is accomplished by calling the `diff_to()` or `diff_from()` method on one adapter and passing the other adapter as a parameter.
 
-![Diffsync Diff Creation](https://raw.githubusercontent.com/networktocode/diffsync/develop/docs/images/diffsync_diff_creation.png "Diffsync Diff Creation")
+![DiffSync Diff Creation](https://raw.githubusercontent.com/networktocode/diffsync/develop/docs/images/diffsync_diff_creation.png "DiffSync Diff Creation")
 
 You can also ask DiffSync to “sync” one data set onto the other, and it will instruct your adapter as to the steps it needs to take to make sure that its data set accurately reflects the other. In Python, this is accomplished by calling the `sync_to()` or `sync_from()` method on one adapter and passing the other adapter as a parameter.
 
-![Diffsync Sync](https://raw.githubusercontent.com/networktocode/diffsync/develop/docs/images/diffsync_sync.png "Diffsync Sync")
+![DiffSync Sync](https://raw.githubusercontent.com/networktocode/diffsync/develop/docs/images/diffsync_sync.png "DiffSync Sync")
 
 # Simple Example
 

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

@@ -14,32 +14,33 @@ 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 (
+    Any,
     Callable,
     ClassVar,
     Dict,
     List,
     Optional,
+    Set,
     Tuple,
     Type,
     Union,
-    Any,
-    Set,
 )
-import warnings
 
-from pydantic import ConfigDict, BaseModel, PrivateAttr
 import structlog  # type: ignore
+from pydantic import BaseModel, ConfigDict, PrivateAttr
+from typing_extensions import deprecated
 
 from diffsync.diff import Diff
-from diffsync.enum import DiffSyncModelFlags, DiffSyncFlags, DiffSyncStatus
+from diffsync.enum import DiffSyncFlags, DiffSyncModelFlags, DiffSyncStatus
 from diffsync.exceptions import (
     DiffClassMismatch,
     ObjectAlreadyExists,
-    ObjectStoreWrongType,
     ObjectNotFound,
+    ObjectStoreWrongType,
 )
 from diffsync.helpers import DiffSyncDiffer, DiffSyncSyncer
 from diffsync.store import BaseStore
@@ -69,7 +70,7 @@ class DiffSyncModel(BaseModel):
     be included in **at most** one of these three tuples.
     """
 
-    _modelname: ClassVar[str] = "diffsyncmodel"
+    _modelname: ClassVar[str] = "diffsyncmodel"  # pylint: disable=used-before-assignment
     """Name of this model, used by DiffSync to store and look up instances of this model or its equivalents.
 
     Lowercase by convention; typically corresponds to the class name, but that is not enforced.
@@ -133,16 +134,16 @@ class DiffSyncModel(BaseModel):
         """
         # Make sure that any field referenced by name actually exists on the model
         for attr in cls._identifiers:
-            if attr not in cls.model_fields and not hasattr(cls, attr):
+            if attr not in cls.model_fields and not hasattr(cls, attr):  # pylint: disable=unsupported-membership-test
                 raise AttributeError(f"_identifiers {cls._identifiers} references missing or un-annotated attr {attr}")
         for attr in cls._shortname:
-            if attr not in cls.model_fields:
+            if attr not in cls.model_fields:  # pylint: disable=unsupported-membership-test
                 raise AttributeError(f"_shortname {cls._shortname} references missing or un-annotated attr {attr}")
         for attr in cls._attributes:
-            if attr not in cls.model_fields:
+            if attr not in cls.model_fields:  # pylint: disable=unsupported-membership-test
                 raise AttributeError(f"_attributes {cls._attributes} references missing or un-annotated attr {attr}")
         for attr in cls._children.values():
-            if attr not in cls.model_fields:
+            if attr not in cls.model_fields:  # pylint: disable=unsupported-membership-test
                 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)
@@ -425,13 +426,13 @@ class DiffSyncModel(BaseModel):
 
 
 class Adapter:  # pylint: disable=too-many-public-methods
-    """Class for storing a group of DiffSyncModel instances and diffing/synchronizing to another DiffSync instance."""
+    """Class for storing a group of DiffSyncModel instances and diffing/synchronizing to another Adapter instance."""
 
     # In any subclass, you would add mapping of names to specific model classes here:
     # modelname1 = MyModelClass1
     # modelname2 = MyModelClass2
 
-    type: Optional[str] = None
+    type: Optional[str] = None  # pylint: disable=used-before-assignment
     """Type of the object, will default to the name of the class if not provided."""
 
     top_level: ClassVar[List[str]] = []
@@ -480,7 +481,7 @@ class Adapter:  # pylint: disable=too-many-public-methods
                 raise AttributeError(f'top_level references attribute "{name}" but it is not a DiffSyncModel subclass!')
 
     def __str__(self) -> StrType:
-        """String representation of a DiffSync."""
+        """String representation of an Adapter."""
         if self.type != self.name:
             return f'{self.type} "{self.name}"'
         return self.type
@@ -526,7 +527,7 @@ class Adapter:  # pylint: disable=too-many-public-methods
         return data
 
     def str(self, indent: int = 0) -> StrType:
-        """Build a detailed string representation of this DiffSync."""
+        """Build a detailed string representation of this Adapter."""
         margin = " " * indent
         output = ""
         for modelname in self.top_level:
@@ -557,7 +558,7 @@ class Adapter:  # pylint: disable=too-many-public-methods
     # Synchronization between DiffSync instances
     # ------------------------------------------------------------------------------
 
-    def sync_from(  # pylint: disable=too-many-arguments
+    def sync_from(  # pylint: disable=too-many-arguments, too-many-positional-arguments
         self,
         source: "Adapter",
         diff_class: Type[Diff] = Diff,
@@ -601,7 +602,7 @@ class Adapter:  # pylint: disable=too-many-public-methods
 
         return diff
 
-    def sync_to(  # pylint: disable=too-many-arguments
+    def sync_to(  # pylint: disable=too-many-arguments, too-many-positional-arguments
         self,
         target: "Adapter",
         diff_class: Type[Diff] = Diff,
@@ -835,7 +836,7 @@ class Adapter:  # pylint: disable=too-many-public-methods
     def get_or_instantiate(
         self, model: Type[DiffSyncModel], ids: Dict, attrs: Optional[Dict] = None
     ) -> Tuple[DiffSyncModel, bool]:
-        """Attempt to get the object with provided identifiers or instantiate it with provided identifiers and attrs.
+        """Attempt to get the object with provided identifiers or instantiate and add it with provided identifiers and attrs.
 
         Args:
             model: The DiffSyncModel to get or create.
@@ -848,7 +849,7 @@ class Adapter:  # pylint: disable=too-many-public-methods
         return self.store.get_or_instantiate(model=model, ids=ids, attrs=attrs)
 
     def get_or_add_model_instance(self, obj: DiffSyncModel) -> Tuple[DiffSyncModel, bool]:
-        """Attempt to get the object with provided obj identifiers or instantiate obj.
+        """Attempt to get the object with provided obj identifiers or add obj.
 
         Args:
             obj: An obj of the DiffSyncModel to get or add.
@@ -894,15 +895,10 @@ class Adapter:  # pylint: disable=too-many-public-methods
         return self.store.count(model=model)
 
 
-def DiffSync(*args: Any, **kwargs: Any) -> Adapter:  # noqa  pylint: disable=invalid-name
+@deprecated("'diffsync.DiffSync' is deprecated and will be removed with 2.1, use 'diffsync.Adapter' instead.")
+class DiffSync(Adapter):
     """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-2.0.0 → diffsync-2.1.0}/diffsync/diff.py

@@ -16,11 +16,11 @@ limitations under the License.
 """
 
 from functools import total_ordering
-from typing import Any, Iterator, Optional, Type, List, Dict, Iterable
+from typing import Any, Dict, Iterable, Iterator, List, Optional, Type
 
-from .exceptions import ObjectAlreadyExists
-from .utils import intersection, OrderedDefaultDict
 from .enum import DiffSyncActions
+from .exceptions import ObjectAlreadyExists
+from .utils import OrderedDefaultDict, intersection
 
 # This workaround is used because we are defining a method called `str` in our class definition, which therefore renders
 # the builtin `str` type unusable.
@@ -105,8 +105,7 @@ class Diff:
 
         Since children is already an OrderedDefaultDict, this method is not doing anything special.
         """
-        for child in children.values():
-            yield child
+        yield from children.values()
 
     def summary(self) -> Dict[StrType, int]:
         """Build a dict summary of this Diff and its child DiffElements."""
@@ -161,7 +160,7 @@ class Diff:
 class DiffElement:  # pylint: disable=too-many-instance-attributes
     """DiffElement object, designed to represent a single item/object that may or may not have any diffs."""
 
-    def __init__(
+    def __init__(  # pylint: disable=too-many-positional-arguments
         self,
         obj_type: StrType,
         name: StrType,

{diffsync-2.0.0 → diffsync-2.1.0}/diffsync/exceptions.py

@@ -14,6 +14,7 @@ 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.
 """
+
 from typing import TYPE_CHECKING, Union, Any
 
 if TYPE_CHECKING:

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

@@ -14,14 +14,16 @@ 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.
 """
-from collections.abc import Iterable as ABCIterable, Mapping as ABCMapping
-from typing import Callable, List, Optional, Tuple, Type, TYPE_CHECKING, Dict, Iterable
+
+from collections.abc import Iterable as ABCIterable
+from collections.abc import Mapping as ABCMapping
+from typing import TYPE_CHECKING, Callable, Dict, Iterable, List, Optional, Tuple, Type
 
 import structlog  # type: ignore
 
 from .diff import Diff, DiffElement
-from .enum import DiffSyncModelFlags, DiffSyncFlags, DiffSyncStatus, DiffSyncActions
-from .exceptions import ObjectNotFound, ObjectNotCreated, ObjectNotUpdated, ObjectNotDeleted, ObjectCrudException
+from .enum import DiffSyncActions, DiffSyncFlags, DiffSyncModelFlags, DiffSyncStatus
+from .exceptions import ObjectCrudException, ObjectNotCreated, ObjectNotDeleted, ObjectNotFound, ObjectNotUpdated
 from .utils import intersection, symmetric_difference
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -35,7 +37,7 @@ class DiffSyncDiffer:  # pylint: disable=too-many-instance-attributes
     Independent from Diff and DiffElement as those classes are purely data objects, while this stores some state.
     """
 
-    def __init__(  # pylint: disable=too-many-arguments
+    def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
         self,
         src_diffsync: "Adapter",
         dst_diffsync: "Adapter",
@@ -114,9 +116,9 @@ class DiffSyncDiffer:  # pylint: disable=too-many-instance-attributes
 
             combined_dict = {}
             for uid in dict_src:
-                combined_dict[uid] = (dict_src.get(uid), dict_dst.get(uid))
+                combined_dict[uid] = (dict_src.get(uid), dict_dst.get(uid))  # type: ignore
             for uid in dict_dst:
-                combined_dict[uid] = (dict_src.get(uid), dict_dst.get(uid))
+                combined_dict[uid] = (dict_src.get(uid), dict_dst.get(uid))  # type: ignore
         else:
             # In the future we might support set, etc...
             raise TypeError(f"Type combination {type(src)}/{type(dst)} is not supported... for now")
@@ -137,7 +139,7 @@ class DiffSyncDiffer:  # pylint: disable=too-many-instance-attributes
 
     @staticmethod
     def validate_objects_for_diff(
-        object_pairs: Iterable[Tuple[Optional["DiffSyncModel"], Optional["DiffSyncModel"]]]
+        object_pairs: Iterable[Tuple[Optional["DiffSyncModel"], Optional["DiffSyncModel"]]],
     ) -> None:
         """Check whether all DiffSyncModels in the given dictionary are valid for comparison to one another.
 
@@ -285,7 +287,7 @@ class DiffSyncSyncer:  # pylint: disable=too-many-instance-attributes
     Independent from DiffSync and DiffSyncModel as those classes are purely data objects, while this stores some state.
     """
 
-    def __init__(  # pylint: disable=too-many-arguments
+    def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
         self,
         diff: Diff,
         src_diffsync: "Adapter",

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

@@ -1,4 +1,5 @@
 """BaseStore module."""
+
 from typing import Dict, List, Tuple, Type, Union, TYPE_CHECKING, Optional, Set, Any
 import structlog  # type: ignore
 

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

@@ -1,8 +1,9 @@
 """RedisStore module."""
+
 import copy
 import uuid
-from pickle import loads, dumps  # nosec
-from typing import List, Type, Union, TYPE_CHECKING, Set, Any, Optional, Dict
+from pickle import dumps, loads  # nosec
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Type, Union
 
 try:
     from redis import Redis
@@ -11,7 +12,7 @@ except ImportError as ierr:
     print("Redis is not installed. Have you installed diffsync with redis extra? `pip install diffsync[redis]`")
     raise ierr
 
-from diffsync.exceptions import ObjectNotFound, ObjectStoreException, ObjectAlreadyExists
+from diffsync.exceptions import ObjectAlreadyExists, ObjectNotFound, ObjectStoreException
 from diffsync.store import BaseStore
 
 if TYPE_CHECKING:
@@ -23,7 +24,7 @@ REDIS_DIFFSYNC_ROOT_LABEL = "diffsync"
 class RedisStore(BaseStore):
     """RedisStore class."""
 
-    def __init__(
+    def __init__(  # pylint: disable=too-many-arguments
         self,
         *args: Any,
         store_id: Optional[str] = None,
@@ -167,7 +168,7 @@ class RedisStore(BaseStore):
 
         existing_obj_binary = self._store.get(object_key)
         if existing_obj_binary:
-            existing_obj = loads(existing_obj_binary)
+            existing_obj = loads(existing_obj_binary)  # nosec
             existing_obj_dict = existing_obj.dict()
 
             if existing_obj_dict != obj.dict():

{diffsync-2.0.0 → diffsync-2.1.0}/diffsync/utils.py

@@ -14,6 +14,7 @@ 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.
 """
+
 from collections import OrderedDict
 from typing import Iterator, List, Dict, Optional, TypeVar, Callable, Generic
 

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "diffsync"
-version = "v2.0.0"
+version = "v2.1.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,10 +16,10 @@ include = [
 ]
 
 [tool.poetry.dependencies]
-python = ">=3.8,<4.0"
+python = ">=3.9,<4.0"
 pydantic = "^2.0.0"
-structlog = ">= 20.1.0, < 23.0.0"
-packaging = ">= 21.3, < 24.0"
+structlog = ">= 20.1.0"
+packaging = ">= 21.3"
 colorama = {version = "^0.4.3", optional = true}
 redis = {version = "^4.3", optional = true}
 # typing.Self introduced in 3.11
@@ -30,7 +30,7 @@ redis = ["redis"]
 
 [tool.poetry.group.dev.dependencies]
 pytest = "*"
-pyyaml = "*"
+pyyaml = ">= 6.0.1"
 black = "*"
 pylint = "*"
 pydocstyle = "*"
@@ -42,7 +42,7 @@ mypy = "*"
 pytest-cov = "*"
 pytest-structlog = "*"
 coverage = {extras = ["toml"], version = "*"}
-Sphinx = "*"
+Sphinx = "^6.0.0"
 m2r2 = "*"
 sphinx-rtd-theme = "*"
 toml = "*"
@@ -84,7 +84,6 @@ no-docstring-rgx="^(_|test_)"
 # Pylint and Black disagree about how to format multi-line arrays; Black wins.
 disable = """,
     line-too-long,
-    bad-continuation,
     """
 
 [tool.pylint.miscellaneous]