morango 0.6.11__py2.py3-none-any.whl → 0.8.6__py2.py3-none-any.whl

morango/sync/session.py

@@ -1,11 +1,13 @@
 import logging
 
 from requests import exceptions
+from morango import __version__
 from requests.sessions import Session
 from requests.utils import super_len
 from requests.packages.urllib3.util.url import parse_url
 
 from morango.utils import serialize_capabilities_to_client_request
+from morango.utils import SETTINGS
 
 
 logger = logging.getLogger(__name__)
@@ -35,6 +37,15 @@ class SessionWrapper(Session):
     bytes_sent = 0
     bytes_received = 0
 
+    def __init__(self):
+        super(SessionWrapper, self).__init__()
+        user_agent_header = "morango/{}".format(__version__)
+        if SETTINGS.CUSTOM_INSTANCE_INFO is not None:
+            instances = list(SETTINGS.CUSTOM_INSTANCE_INFO)
+            if instances:
+                user_agent_header += " " + "{}/{}".format(instances[0], SETTINGS.CUSTOM_INSTANCE_INFO.get(instances[0]))
+        self.headers["User-Agent"] = "{} {}".format(user_agent_header, self.headers["User-Agent"])
+
     def request(self, method, url, **kwargs):
         response = None
         try:

morango/sync/syncsession.py

@@ -1,21 +1,20 @@
 """
 The main module to be used for initiating the synchronization of data between morango instances.
 """
-import os
 import json
 import logging
+import os
 import socket
 import uuid
 from io import BytesIO
+from urllib.parse import urljoin
+from urllib.parse import urlparse
 
 from django.utils import timezone
-from django.utils.six import iteritems
-from django.utils.six import raise_from
 from requests.adapters import HTTPAdapter
 from requests.exceptions import HTTPError
 from requests.packages.urllib3.util.retry import Retry
-from django.utils.six.moves.urllib.parse import urljoin
-from django.utils.six.moves.urllib.parse import urlparse
+from django.db import transaction, connection
 
 from .session import SessionWrapper
 from morango.api.serializers import CertificateSerializer
@@ -30,16 +29,20 @@ from morango.errors import MorangoError
 from morango.errors import MorangoResumeSyncError
 from morango.errors import MorangoServerDoesNotAllowNewCertPush
 from morango.models.certificates import Certificate
+from morango.models.certificates import Filter
 from morango.models.certificates import Key
 from morango.models.core import InstanceIDModel
 from morango.models.core import SyncSession
-from morango.sync.controller import SessionController
+from morango.sync.backends.utils import load_backend
+from morango.sync.context import CompositeSessionContext
 from morango.sync.context import LocalSessionContext
 from morango.sync.context import NetworkSessionContext
+from morango.sync.controller import SessionController
 from morango.sync.utils import SyncSignal
 from morango.sync.utils import SyncSignalGroup
 from morango.utils import CAPABILITIES
 from morango.utils import pid_exists
+from morango.sync.utils import lock_partitions
 
 if GZIP_BUFFER_POST in CAPABILITIES:
     from gzip import GzipFile
@@ -47,6 +50,7 @@ if GZIP_BUFFER_POST in CAPABILITIES:
 
 logger = logging.getLogger(__name__)
 
+DBBackend = load_backend(connection)
 
 def _join_with_logical_operator(lst, operator):
     op = ") {operator} (".format(operator=operator)
@@ -224,6 +228,14 @@ class NetworkSyncConnection(Connection):
         if not server_cert.verify(message, session_resp.json().get("signature")):
             raise CertificateSignatureInvalid()
 
+        client_instance = InstanceIDModel.get_or_create_current_instance()[0]
+
+        server_instance_json = session_resp.json().get("server_instance") or "{}"
+        server_instance_id = None
+        if server_instance_json:
+            server_instance = json.loads(server_instance_json)
+            server_instance_id = server_instance.get("id")
+
         # build the data to be used for creating our own syncsession
         data = {
             "id": data["id"],
@@ -238,23 +250,29 @@ class NetworkSyncConnection(Connection):
             "connection_path": self.base_url,
             "client_ip": data["client_ip"],
             "server_ip": data["server_ip"],
-            "client_instance": json.dumps(
+            "client_instance_id": client_instance.id,
+            "client_instance_json": json.dumps(
                 InstanceIDSerializer(
-                    InstanceIDModel.get_or_create_current_instance()[0]
+                    client_instance
                 ).data
             ),
-            "server_instance": session_resp.json().get("server_instance") or "{}",
+            "server_instance_id": server_instance_id,
+            "server_instance_json": session_resp.json().get("server_instance") or "{}",
             "process_id": os.getpid(),
         }
         sync_session = SyncSession.objects.create(**data)
         return SyncSessionClient(self, sync_session)
 
-    def resume_sync_session(self, sync_session_id, chunk_size=None):
+    def resume_sync_session(self, sync_session_id, chunk_size=None, ignore_existing_process=False):
         """
         Resumes an existing sync session given an ID
 
         :param sync_session_id: The UUID of the `SyncSession` to resume
         :param chunk_size: An optional parameter specifying the size for each transferred chunk
+        :type chunk_size: int
+        :param ignore_existing_process:An optional parameter specifying whether to ignore an
+            existing active process ID
+        :type ignore_existing_process: bool
         :return: A SyncSessionClient instance
         :rtype: SyncSessionClient
         """
@@ -270,7 +288,8 @@ class NetworkSyncConnection(Connection):
 
         # check that process of existing session isn't still running
         if (
-            sync_session.process_id
+            not ignore_existing_process
+            and sync_session.process_id
             and sync_session.process_id != os.getpid()
             and pid_exists(sync_session.process_id)
         ):
@@ -283,7 +302,7 @@ class NetworkSyncConnection(Connection):
         try:
             self._get_sync_session(sync_session)
         except HTTPError as e:
-            raise_from(MorangoResumeSyncError("Failure resuming sync session"), e)
+            raise MorangoResumeSyncError("Failure resuming sync session") from e
 
         # update process id
         sync_session.process_id = os.getpid()
@@ -337,11 +356,15 @@ class NetworkSyncConnection(Connection):
             cert_chain_response = self._get_certificate_chain(
                 params={"ancestors_of": parent_cert.id}
             )
-
-            # upon receiving cert chain from server, we attempt to save the chain into our records
-            Certificate.save_certificate_chain(
-                cert_chain_response.json(), expected_last_id=parent_cert.id
-            )
+            cert_chain = cert_chain_response.json()
+            with transaction.atomic():
+                lock_partitions(DBBackend, sync_filter=Filter(cert_chain[0]["id"]))
+                # check again, now that we have a lock
+                if not Certificate.objects.filter(id=parent_cert.id).exists():
+                    # upon receiving cert chain from server, we attempt to save the chain into our records
+                    Certificate.save_certificate_chain(
+                        cert_chain, expected_last_id=parent_cert.id
+                    )
 
         csr_key = Key()
         # build up data for csr
@@ -424,7 +447,7 @@ class NetworkSyncConnection(Connection):
         # convert user arguments into query str for passing to auth layer
         if isinstance(userargs, dict):
             userargs = "&".join(
-                ["{}={}".format(key, val) for (key, val) in iteritems(userargs)]
+                ["{}={}".format(key, val) for (key, val) in userargs.items()]
             )
         return self.session.post(
             self.urlresolve(api_urls.CERTIFICATE), json=data, auth=(userargs, password)
@@ -575,10 +598,8 @@ class TransferClient(object):
         "sync_connection",
         "sync_session",
         "controller",
-        "current_transfer_session",
         "signals",
-        "local_context",
-        "remote_context",
+        "context",
     )
 
     def __init__(self, sync_connection, sync_session, controller):
@@ -590,51 +611,45 @@ class TransferClient(object):
         self.sync_connection = sync_connection
         self.sync_session = sync_session
         self.controller = controller
-        self.current_transfer_session = None
         self.signals = SyncClientSignals()
 
-        # TODO: come up with strategy to use only one context here
-        self.remote_context = NetworkSessionContext(
-            sync_connection, sync_session=sync_session
-        )
-        self.local_context = LocalSessionContext(
-            sync_session=sync_session, capabilities=self.remote_context.capabilities
+        capabilities = sync_connection.server_info.get("capabilities", [])
+        self.context = CompositeSessionContext(
+            [LocalSessionContext(), NetworkSessionContext(sync_connection)],
+            sync_session=sync_session,
+            capabilities=capabilities,
         )
+        self.controller.context = self.context
 
-    def proceed_to_and_wait_for(self, stage):
-        contexts = (self.local_context, self.remote_context)
-        for context in contexts:
-            max_interval = 1 if context is self.local_context else 5
-            result = self.controller.proceed_to_and_wait_for(
-                stage, context=context, max_interval=max_interval
-            )
-            if result == transfer_statuses.ERRORED:
-                raise_from(
-                    MorangoError("Stage `{}` failed".format(stage)),
-                    context.error,
-                )
+    @property
+    def current_transfer_session(self):
+        return self.context.transfer_session
+
+    def proceed_to_and_wait_for(self, stage, error_msg=None, callback=None):
+        """
+        Raises an exception if an ERROR result is received from calling `proceed_to_and_wait_for`
+        :param stage: The stage to proceed to
+        :param error_msg: An error message str to use as the exception message if it errors
+        :param callback: A callback to pass along to the controller
+        """
+        result = self.controller.proceed_to_and_wait_for(stage, callback=callback)
+        if result == transfer_statuses.ERRORED:
+            raise MorangoError(
+                error_msg or "Stage `{}` failed".format(self.context.stage)
+            ) from self.context.error
 
     def initialize(self, sync_filter):
         """
         :param sync_filter: Filter
         """
         # set filter on controller
-        self.local_context.update(sync_filter=sync_filter)
-        self.remote_context.update(sync_filter=sync_filter)
+        self.context.update(sync_filter=sync_filter)
 
-        # initialize the transfer session locally
-        status = self.controller.proceed_to_and_wait_for(
-            transfer_stages.INITIALIZING, context=self.local_context, max_interval=1
+        # initialize the transfer session
+        self.proceed_to_and_wait_for(
+            transfer_stages.INITIALIZING,
+            error_msg="Failed to initialize transfer session",
         )
-        if status == transfer_statuses.ERRORED:
-            raise_from(
-                MorangoError("Failed to initialize transfer session"),
-                self.local_context.error,
-            )
-
-        # copy the transfer session to local state and update remote controller context
-        self.current_transfer_session = self.local_context.transfer_session
-        self.remote_context.update(transfer_session=self.current_transfer_session)
 
         self.signals.session.started.fire(
             transfer_session=self.current_transfer_session
@@ -643,21 +658,21 @@ class TransferClient(object):
         # backwards compatibility for the queuing signal as it included both serialization
         # and queuing originally
         with self.signals.queuing.send(transfer_session=self.current_transfer_session):
-            # proceeding to serialization on remote will trigger initialization as well
-            self.proceed_to_and_wait_for(transfer_stages.SERIALIZING)
+            # proceeding to queuing on remote will trigger initialization and serialization as well
             self.proceed_to_and_wait_for(transfer_stages.QUEUING)
 
     def run(self):
+        """
+        Execute the transferring portion of the sync
+        """
         with self.signals.transferring.send(
             transfer_session=self.current_transfer_session
         ) as status:
-            self._transfer(callback=status.in_progress.fire)
+            self.proceed_to_and_wait_for(
+                transfer_stages.TRANSFERRING, callback=status.in_progress.fire
+            )
 
     def finalize(self):
-        # if not initialized, we don't need to finalize
-        if not self.current_transfer_session:
-            return
-
         with self.signals.dequeuing.send(
             transfer_session=self.current_transfer_session
         ):
@@ -667,26 +682,6 @@ class TransferClient(object):
         self.signals.session.completed.fire(
             transfer_session=self.current_transfer_session
         )
-        self.current_transfer_session = None
-
-    def _transfer(self, callback=None):
-        result = transfer_statuses.PENDING
-
-        while result not in transfer_statuses.FINISHED_STATES:
-            result = self.controller.proceed_to(
-                transfer_stages.TRANSFERRING, context=self.remote_context
-            )
-            self.local_context.update(
-                stage=transfer_stages.TRANSFERRING, stage_status=result
-            )
-            if callback is not None:
-                callback()
-
-        if result == transfer_statuses.ERRORED:
-            raise_from(
-                MorangoError("Failure occurred during transfer"),
-                self.remote_context.error,
-            )
 
 
 class PushClient(TransferClient):
@@ -696,8 +691,7 @@ class PushClient(TransferClient):
 
     def __init__(self, *args, **kwargs):
         super(PushClient, self).__init__(*args, **kwargs)
-        self.local_context.update(is_push=True)
-        self.remote_context.update(is_push=True)
+        self.context.update(is_push=True)
 
 
 class PullClient(TransferClient):
@@ -707,5 +701,4 @@ class PullClient(TransferClient):
 
     def __init__(self, *args, **kwargs):
         super(PullClient, self).__init__(*args, **kwargs)
-        self.local_context.update(is_push=False)
-        self.remote_context.update(is_push=False)
+        self.context.update(is_push=False)

morango/sync/utils.py

@@ -230,3 +230,21 @@ class SyncSignalGroup(SyncSignal):
         Fires the `completed` signal.
         """
         self.completed.fire()
+
+
+def lock_partitions(backend, sync_filter=None, shared=False):
+    """
+    Lock all partitions for a filter, and really lock everything if the filter is null
+
+    :type backend: morango.sync.backends.base.BaseSQLWrapper
+    :type sync_filter: morango.models.certificates.Filter|None
+    :type shared: bool
+    """
+    if sync_filter is None:
+        backend._lock_all_partitions(shared=shared)
+    else:
+        # parse the first 32 chars to obtain the primary partitions in the filter
+        partitions = set(f[:32] for f in sync_filter)
+        # for every unique partition, acquire a lock
+        for partition in partitions:
+            backend._lock_partition(partition, shared=shared)

morango/urls.py

@@ -1,4 +1,4 @@
-from django.conf.urls import include
-from django.conf.urls import url
+from django.urls import include
+from django.urls import path
 
-urlpatterns = [url(r"^api/morango/v1/", include("morango.api.urls"))]
+urlpatterns = [path("api/morango/v1/", include("morango.api.urls"))]

morango/utils.py

@@ -1,14 +1,13 @@
 import os
-import six
 from importlib import import_module
 
 from django.conf import settings
 
 from morango.constants import settings as default_settings
 from morango.constants.capabilities import ALLOW_CERTIFICATE_PUSHING
-from morango.constants.capabilities import GZIP_BUFFER_POST
 from morango.constants.capabilities import ASYNC_OPERATIONS
 from morango.constants.capabilities import FSIC_V2_FORMAT
+from morango.constants.capabilities import GZIP_BUFFER_POST
 
 
 def do_import(import_string):
@@ -32,7 +31,7 @@ class Settings(object):
     def __getattribute__(self, key):
         """Coalesces settings with the defaults"""
         value = getattr(settings, key, getattr(default_settings, key, None))
-        if key == "MORANGO_INSTANCE_INFO" and isinstance(value, six.string_types):
+        if key == "MORANGO_INSTANCE_INFO" and isinstance(value, str):
             value = dict(do_import(value))
         return value
 

{morango-0.6.11.dist-info → morango-0.8.6.dist-info}/METADATA

@@ -1,30 +1,47 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: morango
-Version: 0.6.11
+Version: 0.8.6
 Summary: Pure Python sqlite-based Django DB replication engine.
 Home-page: https://github.com/learningequality/morango
 Author: Learning Equality
 Author-email: dev@learningequality.org
 License: MIT
 Keywords: database,syncing,morango
-Platform: UNKNOWN
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Development Status :: 4 - Beta
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
 Classifier: Programming Language :: Python :: 3.6
+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
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.6,  <3.14
 Description-Content-Type: text/markdown
-Requires-Dist: django (<2,>=1.10)
-Requires-Dist: django-mptt (<0.10.0)
-Requires-Dist: rsa (<3.5,>=3.4.2)
-Requires-Dist: djangorestframework (==3.9.1)
-Requires-Dist: django-ipware (<1.2,>=1.1.6)
-Requires-Dist: future (==0.16.0)
+License-File: LICENSE
+License-File: AUTHORS.md
+Requires-Dist: django<4,>=3
+Requires-Dist: django-mptt>0.10.0
+Requires-Dist: rsa<4.10
+Requires-Dist: djangorestframework>3.10
+Requires-Dist: django-ipware==4.0.2
 Requires-Dist: requests
 Requires-Dist: ifcfg
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # Morango
 
@@ -57,5 +74,3 @@ make docs
 # auto-build and refresh docs on edit
 make docs-autobuild
 ```
-
-

morango-0.8.6.dist-info/RECORD

@@ -0,0 +1,79 @@
+morango/__init__.py,sha256=VpASnrti7EGWxUfSWGgERUfe7NLJltfVXYosOzHbpPg,22
+morango/apps.py,sha256=bs_LaTt1038Oh0OOWqaZKpF8rL9cg8rqW4hftIILPw8,559
+morango/errors.py,sha256=okjt7FqSHIf3x9SmnmoW6aqNJ_g7Ye3Fx7tuQSNUYEI,1223
+morango/proquint.py,sha256=YRjgceaYD_wDE8R-21AK5m6MSzbarIBP_kDxJ_gHsbQ,3679
+morango/registry.py,sha256=LcHyrNqcqSBAEHJDMS0pinKKzkxRTZjxEyAeZhtrKgo,9480
+morango/urls.py,sha256=pIjnq01BUNxnC0BucRXMr_0H366U5l88k65r67JtHK8,131
+morango/utils.py,sha256=psppzkIjlrmWI2bq2a1wGW0f_0VhdszYleLbm4C4aAs,3652
+morango/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+morango/api/fields.py,sha256=LjEuUrF86JABN45HSXHpUoWHHBDeb73jqD_uS6QY0EA,273
+morango/api/parsers.py,sha256=PxNHz94V3VrSCEVYxuTRO2h8mTg9H7WSy891BxUvsac,557
+morango/api/permissions.py,sha256=B3biuWZfm1VXbIO5pKR2jYBNQBfgY2oKfX3dargtb6A,3550
+morango/api/serializers.py,sha256=GtG_6wcJst68o3NHuIi2q_pX9cOIIIrqmHDZRgR-BdE,5444
+morango/api/urls.py,sha256=D3VFRf4wm1u-Pswu6ZGqJoG-UHQFTI7GGXcqNyz0t5Y,1037
+morango/api/viewsets.py,sha256=qxc4RhQrnJKVAq6F1X9Yo1tv3eGmvF0QJ8-gBrR9lOA,20859
+morango/constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+morango/constants/api_urls.py,sha256=mmGJyyVtrMxjIMAF2iBHbjGVndsvW_z1IQH-GhW3L-g,453
+morango/constants/capabilities.py,sha256=KaTQpfpg6l4G0aGXJnOKi7ibbshdg-1fA9aLl-Qc_Oc,166
+morango/constants/settings.py,sha256=dygRwRZhYkTdRhEltc5QqdoQBLkuZ-f9fdFMVrCaDpQ,2009
+morango/constants/transfer_stages.py,sha256=mp-1V22ba0gKdylJgnUJ8Jh-Qs9-3-LsY_Q_cxRUgmI,1378
+morango/constants/transfer_statuses.py,sha256=BU3_dx7RxXpWF3pDjC9JsDe2xzKSGiqZFVBbdIY7_aQ,509
+morango/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+morango/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+morango/management/commands/cleanupsyncs.py,sha256=Huaz8etLNbmW8X-Vy4x1QY801JYln0iyaeUTJF2L3kE,4833
+morango/migrations/0001_initial.py,sha256=ZFEKusKCIUsgUuHpF-eWqEqu7FrhO2ikkfu5KfYfXx0,11892
+morango/migrations/0001_squashed_0024_auto_20240129_1757.py,sha256=K-71iKz9cKpb-zrxuoDJVWafZM3U_hM6EpX6aNzsFjM,21770
+morango/migrations/0002_auto_20170511_0400.py,sha256=9EQcTl2xHd-rwx_NWCLzo8GU3u7MFA3WOryyKYEbHUw,2263
+morango/migrations/0002_store_idx_morango_deserialize.py,sha256=AbfcuoovuViGRugR5lH86E3JgfgBa_4koTp5vMiUAh8,568
+morango/migrations/0003_auto_20170519_0543.py,sha256=5YfHW6IcT57tgaXW6pnWHmL6kfgauTW2nao9zQr3nP8,641
+morango/migrations/0004_auto_20170520_2112.py,sha256=T7rGjSPXUGnanDr5SJKj5SHZEQYSIaND60vRaK3DObw,517
+morango/migrations/0005_auto_20170629_2139.py,sha256=PL1I3wybrDgDxY8hSmZmUfpxOulr6O2ywui7ue_dvKw,654
+morango/migrations/0006_instanceidmodel_system_id.py,sha256=L4Y5VN1-IBnBPs-lyQrJronf5lrXjvwGFSTKuug-jjo,435
+morango/migrations/0007_auto_20171018_1615.py,sha256=otylWm8eBH8W_fJx-W5C6e8mfhqPdrb-6SZh0GCpFZo,8149
+morango/migrations/0008_auto_20171114_2217.py,sha256=x_2rKsqfH-yRHmuV3qnBgPRBBe0C2Z08aryWcBZU_jw,2085
+morango/migrations/0009_auto_20171205_0252.py,sha256=XxkPK4AsERDw6ZBojS0M1ElMTuhVjxRWDSMDMnvPbDM,359
+morango/migrations/0010_auto_20171206_1615.py,sha256=2Svr2sMBO31fOzm26HdgAL-YmHGOzgWnDMEuoaDWrOU,800
+morango/migrations/0011_sharedkey.py,sha256=fZkD4-2d628Cg0-ekvQnI_CAIVCuei4R2zre9_i87ms,926
+morango/migrations/0012_auto_20180927_1658.py,sha256=29ibsHWltRyUk3lXR3ZLzmeCY2SRWpW7KXU8zmTzIfk,946
+morango/migrations/0013_auto_20190627_1513.py,sha256=eG6pdMh_xqz9nfn9z0F987rR12i6JswSFFKCjsHwsCQ,464
+morango/migrations/0014_syncsession_extra_fields.py,sha256=11qg91F0ZCaxh3AS17xEUH5xlxBDyWSi3RRgbE593xE,440
+morango/migrations/0015_auto_20200508_2104.py,sha256=nD3FkddbgWYDoIau79X5-gq_xMjlJV_EQF14MYff-Fc,667
+morango/migrations/0016_store_deserialization_error.py,sha256=yGenUzUrcIzWDR2_7h0tU_8M-2tBC2-ldjcPrV6510M,441
+morango/migrations/0017_store_last_transfer_session_id.py,sha256=oVQUlvo247JgecQ2NY-Xb5kyoK4rRhb09YbrRj1enmo,521
+morango/migrations/0018_auto_20210714_2216.py,sha256=ghAZmcFXqlWPuSiFt-ikwfZJg-3IKOXiC_sa6nbzme0,1599
+morango/migrations/0019_auto_20220113_1807.py,sha256=jRbNz8OQScW4KN-JsY_KZb7yy5kSO30iWhSAhCHC6w4,1521
+morango/migrations/0020_postgres_fix_nullable.py,sha256=QHgSdEzmIzpLn0HXDWRepmBhvc7S-1emErNQVyrYAfA,1206
+morango/migrations/0021_store_partition_index_create.py,sha256=B9p20AQA0BVqlfmaPYd4RAghYtJKvrdzafWIUAbV7w0,2209
+morango/migrations/0022_rename_instance_fields.py,sha256=xn2PGlgkHOPRYBHrbGdh6XGGHl_X5HPFEIgmGIG0Ycw,592
+morango/migrations/0023_add_instance_id_fields.py,sha256=ovO_AVGLPlLpEc72UhrJ0TpFYCci_CzDcEdmnNJzLew,635
+morango/migrations/0024_auto_20240129_1757.py,sha256=Buy1T4PiTFo8zP7p2HY-3gmiJurQsSnu7CBgTSvOxXg,762
+morango/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+morango/models/__init__.py,sha256=ws6VwRPs7iKLRfFSuRpUESTZlGEmSk0Nv61chh-Gn2Q,1722
+morango/models/certificates.py,sha256=4s7YTNhmTXLyPuhpZZay-Dei8pdq2WqlOshNwGxzlOE,19380
+morango/models/core.py,sha256=-yZ01bS0nXNV0BL_wTHEc4x-7Hh_69hn3MyUunGK2SU,39080
+morango/models/fsic_utils.py,sha256=B9RM-uPZFvEXWbsPeeit5qA21gKGpA0NkKCLFIdNI_0,7130
+morango/models/manager.py,sha256=fzzX7k8qV5W5dMBb0ASOBNRJRpvQZbEG1hgyuMtzt4g,163
+morango/models/query.py,sha256=eHcf9PYYEDShN6lRng7Ow9RJwNFPdKI1hDbVUXeyl9U,869
+morango/models/signals.py,sha256=R17Fqddbg2AgAVnH4oZPrDQMWi94R2XsLmnUbrgKS2I,478
+morango/models/utils.py,sha256=8J138TR3FkslovfUWkLLEpODieFtmHKne7Lm1I8iPXk,6588
+morango/models/fields/__init__.py,sha256=dzxg8-_v3irXkPnyCsiVDur0gG0RJfKzFcshjL6Y-9s,225
+morango/models/fields/crypto.py,sha256=Q_y7s-UpFEz9zXFaAkEDOmqwx4b19F7wbTafpd_XPp4,14509
+morango/models/fields/uuids.py,sha256=w7M8KlA8oLPascq14tcor89V92IGxx2XtdweS-0lF6A,4275
+morango/sync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+morango/sync/context.py,sha256=r3sHkmb7OYCqLm3C0ADv2qvdXeZHTBwLGe6wkMdOMGc,18163
+morango/sync/controller.py,sha256=ZfvXFNptduxhtF72E07o9Dh3Fcnk7xSyjvMTZ---oZw,11666
+morango/sync/operations.py,sha256=ErZ-W4MiCUVl_vn0pFi8DWGgT1C9wOAH4AagCMdLBOs,69502
+morango/sync/session.py,sha256=9CTLhpEPM8q1M_b2HHxouZbzm7vBJoImoqPWqdodgII,3853
+morango/sync/syncsession.py,sha256=fhm7r3DHeBXDSWG0k7I2slhgxe3ebtmXouZHTzUQ9cs,25846
+morango/sync/utils.py,sha256=BrG8CYVmaAhRNa_HYuPCYSnncskSsW_ig0Cf7xsY2mo,8792
+morango/sync/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+morango/sync/backends/base.py,sha256=zQP5hOB2Qw0qv0G00LXFHl2GQ3b0bheyujdNVl5rT-8,10867
+morango/sync/backends/postgres.py,sha256=N0IeXN67AkdQKlD20b8LQZ1ocdarapL8pqu8FQAc6lM,19850
+morango/sync/backends/sqlite.py,sha256=vg7kWFIF346-NjVwexYfjYbrrOyzzvcCmk5uUkqhabw,12850
+morango/sync/backends/utils.py,sha256=UvyYByzRenOwtDvLPO_1wIOE8Yr88FnuAM2c4VSk7uQ,5145
+morango-0.8.6.dist-info/licenses/AUTHORS.md,sha256=9Ussd3Fq3RPjHyQT_3AyGss5jiVbn858WQuIBOi1ajI,276
+morango-0.8.6.dist-info/licenses/LICENSE,sha256=RkI6MjmrrTKa3aoPAVyk9QdeLZclcrKds6FH3phRSRU,1074
+morango-0.8.6.dist-info/METADATA,sha256=Qy4IvvYvDLsslhq2TzulHvZDzqEBvPBhMjFCwpBi0IQ,2819
+morango-0.8.6.dist-info/WHEEL,sha256=AeO2BvogYWm3eGaHCvhzmUYt8ia7KfURiHzO_1atlys,109
+morango-0.8.6.dist-info/top_level.txt,sha256=pzREWN0EeEq3yHDRast9XI081Ow_rtcm7WV0ZQTlIPY,8
+morango-0.8.6.dist-info/RECORD,,

{morango-0.6.11.dist-info → morango-0.8.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: setuptools (79.0.1)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

morango/models/morango_mptt.py

@@ -1,33 +0,0 @@
-from mptt import managers
-from mptt import models
-from mptt import querysets
-
-from .manager import SyncableModelManager
-from .query import SyncableModelQuerySet
-
-
-class MorangoTreeQuerySet(querysets.TreeQuerySet, SyncableModelQuerySet):
-    pass
-
-
-class MorangoMPTTTreeManager(managers.TreeManager, SyncableModelManager):
-    def get_queryset(self):
-        return MorangoTreeQuerySet(self.model, using=self._db)
-
-    def _mptt_update(self, qs=None, **items):
-        items["update_dirty_bit_to"] = None
-        return super(MorangoMPTTTreeManager, self)._mptt_update(qs, **items)
-
-
-class MorangoMPTTModel(models.MPTTModel):
-    """
-    Any model that inherits from ``SyncableModel`` that also wants to inherit from ``MPTTModel`` should instead inherit
-    from ``MorangoMPTTModel``, which modifies some behavior to make it safe for the syncing system.
-    """
-
-    _internal_mptt_fields_not_to_serialize = ("lft", "rght", "tree_id", "level")
-
-    objects = MorangoMPTTTreeManager()
-
-    class Meta:
-        abstract = True