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

morango/models/fields/crypto.py

@@ -21,6 +21,16 @@ except ImportError:
     M2CRYPTO_EXISTS = False
 
 try:
+    # Pre-empt the PanicException that importing cryptography can cause
+    # when we are using a non-compatible version of cffi on Python 3.13
+    # this happens because of static depdendency bundling in Kolibri
+    import cffi
+
+    if sys.version_info > (3, 13):
+        if hasattr(cffi, "__version_info__"):
+            if cffi.__version_info__ < (1, 17, 1):
+                raise ImportError
+
     from cryptography.hazmat.backends import default_backend
     from cryptography import exceptions as crypto_exceptions
 
@@ -40,11 +50,15 @@ try:
     CRYPTOGRAPHY_EXISTS = True
 except ImportError:
     CRYPTOGRAPHY_EXISTS = False
+except BaseException as e:
+    # Still catch PanicExceptions just in case.
+    if "Python API call failed" in str(e):
+        CRYPTOGRAPHY_EXISTS = False
+    else:
+        # Otherwise raise the error again to avoid silently catching other errors
+        raise
 
-if sys.version_info[0] < 3:
-    from base64 import encodestring as b64encode, decodestring as b64decode
-else:
-    from base64 import encodebytes as b64encode, decodebytes as b64decode
+from base64 import encodebytes as b64encode, decodebytes as b64decode
 
 
 PKCS8_HEADER = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A"
@@ -347,7 +361,7 @@ class RSAKeyBaseField(models.TextField):
 
 
 class PublicKeyField(RSAKeyBaseField):
-    def from_db_value(self, value, expression, connection, context):
+    def from_db_value(self, value, expression, connection):
         if not value:
             return None
         return Key(public_key_string=value)
@@ -366,7 +380,7 @@ class PublicKeyField(RSAKeyBaseField):
 
 
 class PrivateKeyField(RSAKeyBaseField):
-    def from_db_value(self, value, expression, connection, context):
+    def from_db_value(self, value, expression, connection):
         if not value:
             return None
         return Key(private_key_string=value)

morango/models/fields/uuids.py

@@ -2,6 +2,7 @@ import hashlib
 import uuid
 
 from django.db import models
+
 from morango.utils import _assert
 
 
@@ -41,7 +42,7 @@ class UUIDField(models.CharField):
                 raise TypeError(self.error_messages["invalid"] % {"value": value})
         return value.hex
 
-    def from_db_value(self, value, expression, connection, context):
+    def from_db_value(self, value, expression, connection):
         return self.to_python(value)
 
     def to_python(self, value):

morango/models/utils.py

@@ -1,5 +1,4 @@
 import hashlib
-import ifcfg
 import os
 import platform
 import socket
@@ -7,10 +6,10 @@ import subprocess
 import sys
 import uuid
 
-from .fields.uuids import sha2_uuid
-
+import ifcfg
 from django.conf import settings
-from django.utils import six
+
+from .fields.uuids import sha2_uuid
 
 
 def _get_database_path():
@@ -109,7 +108,7 @@ def _get_android_uuid():
 def _do_salted_hash(value):
     if not value:
         return ""
-    if not isinstance(value, six.string_types):
+    if not isinstance(value, str):
         value = str(value)
     try:
         value = value.encode()
@@ -185,7 +184,7 @@ def _get_mac_address_flags(mac):
     """
     See: https://en.wikipedia.org/wiki/MAC_address#Universal_vs._local
     """
-    if isinstance(mac, six.integer_types):
+    if isinstance(mac, int):
         mac = _mac_int_to_ether(mac)
 
     first_octet = int(mac[:2], base=16)

morango/proquint.py

@@ -4,7 +4,6 @@ The simplest ways to use this module are the :func:`humanize` and :func:`uuid`
 functions. For tighter control over the output, see :class:`HumanHasher`.
 """
 import uuid
-from django.utils import six
 
 # Copyright (c) 2014 SUNET. All rights reserved.
 #
@@ -59,7 +58,7 @@ def from_int(data):
     :type data: int
     :rtype: string
     """
-    if not isinstance(data, six.integer_types):
+    if not isinstance(data, int):
         raise TypeError("Input must be integer")
 
     res = []
@@ -84,7 +83,7 @@ def to_int(data):
     :type data: string
     :rtype: int
     """
-    if not isinstance(data, six.string_types):
+    if not isinstance(data, str):
         raise TypeError("Input must be string")
 
     res = 0

morango/registry.py

@@ -7,7 +7,6 @@ import sys
 from collections import OrderedDict
 
 from django.db.models.fields.related import ForeignKey
-from django.utils import six
 
 from morango.constants import transfer_stages
 from morango.errors import InvalidMorangoModelConfiguration
@@ -19,7 +18,7 @@ from morango.utils import SETTINGS
 
 def _get_foreign_key_classes(m):
     return set(
-        [field.rel.to for field in m._meta.fields if isinstance(field, ForeignKey)]
+        [field.related_model for field in m._meta.fields if isinstance(field, ForeignKey)]
     )
 
 
@@ -36,6 +35,24 @@ def _multiple_self_ref_fk_check(class_model):
     return False
 
 
+def _check_manager(name, objects):
+    from morango.models.manager import SyncableModelManager
+    from morango.models.query import SyncableModelQuerySet
+    # syncable model checks
+    if not isinstance(objects, SyncableModelManager):
+        raise InvalidMorangoModelConfiguration(
+            "Manager for {} must inherit from SyncableModelManager.".format(
+                name
+            )
+        )
+    if not isinstance(objects.none(), SyncableModelQuerySet):
+        raise InvalidMorangoModelConfiguration(
+            "Queryset for {} model must inherit from SyncableModelQuerySet.".format(
+                name
+            )
+        )
+
+
 class SyncableModelRegistry(object):
     def __init__(self):
         self.profile_models = {}
@@ -99,8 +116,6 @@ class SyncableModelRegistry(object):
 
         import django.apps
         from morango.models.core import SyncableModel
-        from morango.models.manager import SyncableModelManager
-        from morango.models.query import SyncableModelQuerySet
 
         model_list = []
         for model in django.apps.apps.get_models():
@@ -111,49 +126,10 @@ class SyncableModelRegistry(object):
                     raise InvalidMorangoModelConfiguration(
                         "Syncing models with more than 1 self referential ForeignKey is not supported."
                     )
-                try:
-                    from mptt import models
-                    from morango.models.morango_mptt import (
-                        MorangoMPTTModel,
-                        MorangoMPTTTreeManager,
-                        MorangoTreeQuerySet,
-                    )
+                # Check both the objects and the syncing_objects querysets.
+                _check_manager(name, model.objects)
+                _check_manager(name, model.syncing_objects)
 
-                    # mptt syncable model checks
-                    if issubclass(model, models.MPTTModel):
-                        if not issubclass(model, MorangoMPTTModel):
-                            raise InvalidMorangoModelConfiguration(
-                                "{} that inherits from MPTTModel, should instead inherit from MorangoMPTTModel.".format(
-                                    name
-                                )
-                            )
-                        if not isinstance(model.objects, MorangoMPTTTreeManager):
-                            raise InvalidMorangoModelConfiguration(
-                                "Manager for {} must inherit from MorangoMPTTTreeManager.".format(
-                                    name
-                                )
-                            )
-                        if not isinstance(model.objects.none(), MorangoTreeQuerySet):
-                            raise InvalidMorangoModelConfiguration(
-                                "Queryset for {} model must inherit from MorangoTreeQuerySet.".format(
-                                    name
-                                )
-                            )
-                except ImportError:
-                    pass
-                # syncable model checks
-                if not isinstance(model.objects, SyncableModelManager):
-                    raise InvalidMorangoModelConfiguration(
-                        "Manager for {} must inherit from SyncableModelManager.".format(
-                            name
-                        )
-                    )
-                if not isinstance(model.objects.none(), SyncableModelQuerySet):
-                    raise InvalidMorangoModelConfiguration(
-                        "Queryset for {} model must inherit from SyncableModelQuerySet.".format(
-                            name
-                        )
-                    )
                 if model._meta.many_to_many:
                     raise UnsupportedFieldType(
                         "{} model with a ManyToManyField is not supported in morango."
@@ -178,7 +154,7 @@ class SyncableModelRegistry(object):
                     self._insert_model_in_dependency_order(model, profile)
 
         # for each profile, create a dict mapping from morango_model_name to model class
-        for profile, model_list in six.iteritems(self.profile_models):
+        for profile, model_list in self.profile_models.items():
             mapping = OrderedDict()
             for model in model_list:
                 mapping[model.morango_model_name] = model

morango/sync/backends/utils.py

@@ -1,8 +1,7 @@
 import sqlite3
+from functools import lru_cache
 from importlib import import_module
 
-from django.utils.lru_cache import lru_cache
-
 from morango.errors import MorangoError
 
 
@@ -110,15 +109,15 @@ class TemporaryTable(object):
         """
         fields = []
         params = []
-        with self.connection.schema_editor() as schema_editor:
-            for field in self.fields:
-                # generates the SQL expression for the table column
-                field_sql, field_params = schema_editor.column_sql(
-                    self, field, include_default=True
-                )
-                field_sql_name = self.connection.ops.quote_name(field.column)
-                fields.append("{name} {sql}".format(name=field_sql_name, sql=field_sql))
-                params.extend(field_params)
+        schema_editor = self.connection.schema_editor()
+        for field in self.fields:
+            # generates the SQL expression for the table column
+            field_sql, field_params = schema_editor.column_sql(
+                self, field, include_default=True
+            )
+            field_sql_name = self.connection.ops.quote_name(field.column)
+            fields.append("{name} {sql}".format(name=field_sql_name, sql=field_sql))
+            params.extend(field_params)
         with self.connection.cursor() as c:
             self.backend._create_temporary_table(c, self.sql_name, fields, params)
 

morango/sync/context.py

@@ -63,6 +63,13 @@ class SessionContext(object):
         """
         return self
 
+    def join(self, context):
+        """
+        Perform any processing of session context after passing it to the middleware, which will
+        receive the result returned by `prepare` after that has happened
+        """
+        pass
+
     def update(
         self,
         transfer_session=None,
@@ -83,7 +90,7 @@ class SessionContext(object):
         :type capabilities: str[]|None
         :type error: BaseException|None
         """
-        if transfer_session and self.transfer_session:
+        if transfer_session and self.transfer_session and transfer_session.id != self.transfer_session.id:
             raise MorangoContextUpdateError("Transfer session already exists")
         elif (
             transfer_session
@@ -92,14 +99,18 @@ class SessionContext(object):
         ):
             raise MorangoContextUpdateError("Sync session mismatch")
 
-        if sync_filter and self.filter:
-            raise MorangoContextUpdateError("Filter already exists")
+        if sync_filter and self.filter and sync_filter != self.filter:
+            if not self.filter.is_subset_of(sync_filter):
+                raise MorangoContextUpdateError("The existing filter must be a subset of the new filter")
+            if transfer_stages.stage(self.stage) > transfer_stages.stage(transfer_stages.INITIALIZING):
+                raise MorangoContextUpdateError("Cannot update filter after initializing stage")
 
         if is_push is not None and self.is_push is not None:
             raise MorangoContextUpdateError("Push/pull method already exists")
 
         self.transfer_session = transfer_session or self.transfer_session
-        self.filter = sync_filter or self.filter
+        if sync_filter or self.filter:
+            self.filter = Filter.add(self.filter, sync_filter)
         self.is_push = is_push if is_push is not None else self.is_push
         self.capabilities = set(capabilities or self.capabilities) & CAPABILITIES
         self.update_state(stage=stage, stage_status=stage_status)
@@ -402,13 +413,40 @@ class CompositeSessionContext(SessionContext):
         """
         return self.children[self._counter % len(self.children)]
 
+    def join(self, context):
+        """
+        This updates some context attributes that really only make sense logically for what an
+        operation might change during a sync
+
+        :param context: The context that was returned previously from `prepare`
+        :type context: SessionContext
+        """
+        updates = {}
+        if not self.transfer_session and context.transfer_session:
+            # if the transfer session is being resumed, we'd detect a different stage here,
+            # and thus we reset the counter, so we can be sure to start fresh at that stage
+            # on the next invocation of the middleware
+            if (
+                context.transfer_session.transfer_stage
+                and self._stage
+                and context.transfer_session.transfer_stage != self._stage
+            ):
+                self._counter = 0
+                updates.update(
+                    stage=context.transfer_session.transfer_stage,
+                    stage_status=transfer_statuses.PENDING,
+                )
+            updates.update(transfer_session=context.transfer_session)
+        if self.filter != context.filter:
+            updates.update(sync_filter=context.filter)
+        if self.capabilities != context.capabilities:
+            updates.update(capabilities=context.capabilities)
+        if self.error != context.error:
+            updates.update(error=context.error)
+        if updates:
+            self.update(**updates)
+
     def update(self, stage=None, stage_status=None, **kwargs):
-        """
-        Updates the context object and its state
-        :param stage: The str transfer stage
-        :param stage_status: The str transfer stage status
-        :param kwargs: Other arguments to update the context with
-        """
         # update ourselves, but exclude stage and stage_status
         super(CompositeSessionContext, self).update(**kwargs)
         # update children contexts directly, but exclude stage and stage_status
@@ -416,36 +454,6 @@ class CompositeSessionContext(SessionContext):
         # handle state changes after updating children
         self.update_state(stage=stage, stage_status=stage_status)
 
-        # During the initializing stage, we want to make sure to synchronize the transfer session
-        # object between the composite and children contexts, using whatever child context's
-        # transfer session object that was updated on the context during initialization
-        current_stage = stage or self._stage
-        if not self.transfer_session and current_stage == transfer_stages.INITIALIZING:
-            try:
-                transfer_session = next(
-                    c.transfer_session for c in self.children if c.transfer_session
-                )
-                # prepare an updates dictionary, so we can update everything at once
-                updates = dict(transfer_session=transfer_session)
-
-                # if the transfer session is being resumed, we'd detect a different stage here,
-                # and thus we reset the counter, so we can be sure to start fresh at that stage
-                # on the next invocation of the middleware
-                if (
-                    transfer_session.transfer_stage
-                    and transfer_session.transfer_stage != current_stage
-                ):
-                    self._counter = 0
-                    updates.update(
-                        stage=transfer_session.transfer_stage,
-                        stage_status=transfer_statuses.PENDING,
-                    )
-
-                # recurse into update with transfer session and possibly state updates too
-                self.update(**updates)
-            except StopIteration:
-                pass
-
     def update_state(self, stage=None, stage_status=None):
         """
         Updates the state of the transfer

morango/sync/controller.py

@@ -1,4 +1,5 @@
 import logging
+import math
 from time import sleep
 
 from morango.constants import transfer_stages
@@ -207,11 +208,16 @@ class SessionController(object):
         tries = 0
         context = context or self.context
         max_interval = max_interval or context.max_backoff_interval
+        # solve for the number of tries at which our sleep time will always be max_interval
+        max_interval_tries = math.ceil(math.log(max_interval / 0.3 + 1) / math.log(2))
 
         while result not in transfer_statuses.FINISHED_STATES:
             if tries > 0:
                 # exponential backoff up to max_interval
-                sleep(min(0.3 * (2 ** tries - 1), max_interval))
+                if tries >= max_interval_tries:
+                    sleep(max_interval)
+                else:
+                    sleep(0.3 * (2 ** tries - 1))
             result = self.proceed_to(target_stage, context=context)
             tries += 1
             if callable(callback):
@@ -247,6 +253,9 @@ class SessionController(object):
             # invoke the middleware with the prepared context
             result = middleware(prepared_context)
 
+            # return the prepared context back
+            context.join(prepared_context)
+
             # don't update stage result if context's stage was updated during operation
             if context.stage == stage:
                 context.update(stage_status=result)

morango/sync/operations.py

@@ -145,7 +145,7 @@ def _serialize_into_store(profile, filter=None):
         for model in syncable_models.get_models(profile):
             new_store_records = []
             new_rmc_records = []
-            klass_queryset = model.objects.filter(_morango_dirty_bit=True)
+            klass_queryset = model.syncing_objects.filter(_morango_dirty_bit=True)
             if prefix_condition:
                 klass_queryset = klass_queryset.filter(prefix_condition)
             store_records_dict = Store.objects.in_bulk(

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

@@ -7,15 +7,14 @@ 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 django.utils.six.moves.urllib.parse import urljoin
-from django.utils.six.moves.urllib.parse import urlparse
 from requests.adapters import HTTPAdapter
 from requests.exceptions import HTTPError
 from requests.packages.urllib3.util.retry import Retry
+from django.db import transaction, connection
 
 from .session import SessionWrapper
 from morango.api.serializers import CertificateSerializer
@@ -30,9 +29,11 @@ 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.backends.utils import load_backend
 from morango.sync.context import CompositeSessionContext
 from morango.sync.context import LocalSessionContext
 from morango.sync.context import NetworkSessionContext
@@ -41,6 +42,7 @@ 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
@@ -48,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)
@@ -225,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"],
@@ -239,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
         """
@@ -271,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)
         ):
@@ -284,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()
@@ -338,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
@@ -425,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)
@@ -612,12 +634,9 @@ class TransferClient(object):
         """
         result = self.controller.proceed_to_and_wait_for(stage, callback=callback)
         if result == transfer_statuses.ERRORED:
-            raise_from(
-                MorangoError(
-                    error_msg or "Stage `{}` failed".format(self.context.stage)
-                ),
-                self.context.error,
-            )
+            raise MorangoError(
+                error_msg or "Stage `{}` failed".format(self.context.stage)
+            ) from self.context.error
 
     def initialize(self, sync_filter):
         """

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