Rename dsync/DSync to diffsync/DiffSync throughout

Author: glennmatthews

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,10 +1,10 @@
 ---
 name: 🐛 Bug Report
-about: Report a reproducible bug in the current release of DSync
+about: Report a reproducible bug in the current release of DiffSync
 ---
 
 ### Environment
-* DSync version:  <!-- Example: 1.0.0 -->
+* DiffSync version:  <!-- Example: 1.0.0 -->
 * Python version  <!-- Example: 3.7.7 -->
 
 <!-- What happened instead? -->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -4,7 +4,7 @@ about: Propose a new feature or enhancement
 ---
 
 ### Environment
-* DSync version:  <!-- Example: 1.0.0 -->
+* DiffSync version:  <!-- Example: 1.0.0 -->
 
 <!--
     Describe in detail the new functionality you are proposing.
@@ -16,6 +16,6 @@ about: Propose a new feature or enhancement
     Convey an example use case for your proposed feature. Write from the
     perspective of a user who would benefit from the proposed
     functionality and describe how.
---->
+-->
 ### Use Case
 

README.md

@@ -1,12 +1,12 @@
-# dsync
+# DiffSync
 
-DSync is a utility library that can be used to compare and synchronize different datasets.
+DiffSync is a utility library that can be used to compare and synchronize different datasets.
 
 For example, it can be used to compare a list of devices from 2 inventories system and, if required, synchronize them in either direction.
 
 ```python
-A = DSyncSystemA()
-B = DSyncSystemB()
+A = DiffSyncSystemA()
+B = DiffSyncSystemB()
 
 A.load()
 B.load()
@@ -24,24 +24,24 @@ A.sync_to(B)
 
 # Getting Started
 
-To be able to properly compare different datasets, DSync rely on a shared datamodel that both systems must use.
+To be able to properly compare different datasets, DiffSync relies on a shared datamodel that both systems must use.
 
-## Define your model with DSyncModel
+## Define your model with DiffSyncModel
 
-DSyncModel is based on [Pydantic](https://pydantic-docs.helpmanual.io/) and is using Python Typing to define the format of each attribute.
-Each DSyncModel class supports the following class-level attributes:
+DiffSyncModel is based on [Pydantic](https://pydantic-docs.helpmanual.io/) and is using Python Typing to define the format of each attribute.
+Each DiffSyncModel class supports the following class-level attributes:
 - `_modelname` (str) Define the type of the model, it's used to store the data internally (Mandatory)
 - `_identifiers` List(str) List of instance field names used as primary keys for this object (Mandatory)
 - `_shortname` List(str) List of instance field names to use for a shorter name (Optional)
 - `_attributes` List(str) List of additional instance field names for this object (Optional)
 - `_children` Dict: Dict of {`<modelname>`: `field_name`} to indicate how child objects should be stored. (Optional)
 
-> DSyncModel must uniquely identified by their unique id, composed of all fields defined in `_identifiers`. DSyncModel do not support incremental IDs as primary key.
+> DiffSyncModel instances must be uniquely identified by their unique id, composed of all fields defined in `_identifiers`. DiffSyncModel does not support incremental IDs as primary key.
 
 ```python
-from dsync import DSyncModel
+from diffsync import DiffSyncModel
 
-class Site(DSyncModel):
+class Site(DiffSyncModel):
     _modelname = "site"
     _identifiers = ("name",)
     _shortname = ()
@@ -54,16 +54,16 @@ class Site(DSyncModel):
 ```
 
 ### Relationship between models.
-Currently the relationship between models are very loose, by design. Instead of storing an object, it's recommended to store the uid of an object and retrieve it from the store as needed.
+Currently the relationships between models are very loose by design. Instead of storing an object, it's recommended to store the uid of an object and retrieve it from the store as needed.
 
-## DSync
+## DiffSync
 
-A DSync object must reference each model available at the top of the object by its modelname and must have a `top_level` attribute defined to indicate how the diff and the synchronization should be done. In the example below, `"site"` is the only top level objects so the synchronization engine will check all sites and all children of each site (devices)
+A DiffSync object must reference each model available at the top of the object by its modelname and must have a `top_level` attribute defined to indicate how the diff and the synchronization should be done. In the example below, `"site"` is the only top level objects so the synchronization engine will check all sites and all children of each site (devices)
 
 ```python
-from dsync import DSync
+from diffsync import DiffSync
 
-class BackendA(DSync):
+class BackendA(DiffSync):
 
     site = Site
     device = Device
@@ -73,12 +73,12 @@ class BackendA(DSync):
 
 It's up to the user to populate the internal cache with the appropriate data. In the example below we are using the `load()` method to populate the cache but it's not mandatory, it could be done differently
 
-## Store data in a DSync object
+## Store data in a DiffSync object
 
-To add a site to the local cache/store, you need to pass a valid DSyncModel object to the `add()` function.
+To add a site to the local cache/store, you need to pass a valid DiffSyncModel object to the `add()` function.
 ```python
 
-class BackendA(DSync):
+class BackendA(DiffSync):
     [...]
 
     def load(self):
@@ -94,17 +94,17 @@ class BackendA(DSync):
 
 ## Update Remote system on Sync
 
-To update a remote system, you need to extend your DSyncModel class(es) to define your own `create`, `update` and/or `delete` methods for each model.
-A DSyncModel instance stores a reference to its parent DSync class in case you need to use it to look up other model instances from the DSync's cache.
+To update a remote system, you need to extend your DiffSyncModel class(es) to define your own `create`, `update` and/or `delete` methods for each model.
+A DiffSyncModel instance stores a reference to its parent DiffSync class in case you need to use it to look up other model instances from the DiffSync's cache.
 
 ```python
-class Device(DSyncModel):
+class Device(DiffSyncModel):
     [...]
 
     @classmethod
-    def create(cls, dsync, ids, attrs):
+    def create(cls, diffsync, ids, attrs):
         ## TODO add your own logic here to create the device on the remote system
-        return super().create(ids=ids, dsync=dsync, attrs=attrs)
+        return super().create(ids=ids, diffsync=diffsync, attrs=attrs)
 
     def update(self, attrs):
         ## TODO add your own logic here to update the device on the remote system