Fix a memory leak caused by schematics json schemas

.gitignore

@@ -1,4 +1,5 @@
 # uranium
+.virtualenv
 .env
 bin
 build

transmute_core/object_serializers/schematics_serializer.py

@@ -74,16 +74,16 @@ def _translate_to_model(self, model):
         if isinstance(model, BaseType):
             return model
 
+        if model in self._models:
+            return self._models[model]
+
         if isinstance(model, ModelMeta):
-            return ModelType(model)
+            self._models[model] = ModelType(model)
 
         if model not in self._models and isinstance(model, tuple):
             self._models[model] = ListType(self._translate_to_model(model[0]))
 
-        if model in self._models:
-            return self._models[model]
-
-        return model
+        return self._models.get(model, model)
 
     @staticmethod
     def _to_key(model):
@@ -92,7 +92,7 @@ def _to_key(model):
         return model
 
     def load(self, model, value):
-        model = _enforce_instance(model)
+        model = _enforce_type_instance_or_model_class(model)
         try:
             context = get_import_context(oo=True)
             model = self._translate_to_model(model)
@@ -108,7 +108,7 @@ def load(self, model, value):
             raise SerializationException(str(e))
 
     def dump(self, model, value):
-        model = _enforce_instance(model)
+        model = _enforce_type_instance_or_model_class(model)
         try:
             model = self._translate_to_model(model)
             return model.to_primitive(value)
@@ -118,7 +118,12 @@ def dump(self, model, value):
     def to_json_schema(self, model):
         if isinstance(model, Serializable):
             model = model.type
-        model = _enforce_instance(model)
+        # ensure that the model is an instance,
+        # as further processing steps required that it is.
+        model = _enforce_type_instance_or_model_class(model)
+        # once the model is an instance of something, there
+        # are several legacy transforms (like taking a tuple of schematics
+        # models) that require a second transformation to a pure schematics model.
         model = self._translate_to_model(model)
         return _to_json_schema(model)
 
@@ -174,11 +179,15 @@ def _dict_type_to_json_schema(dict_type):
     return {"type": "object", "additionalProperties": _to_json_schema(dict_type.field)}
 
 
-def _enforce_instance(model_or_class):
+def _enforce_type_instance_or_model_class(model_or_class):
     """
-    It's a common mistake to not initialize a
-    schematics class. We should handle that by just
-    calling the default constructor.
+    As a broad range of schematics classes and instances are supported, this
+    ensures that those options are normalized to one of the following:
+
+    * an uninstantiated model
+    * an instantiated type
+
+    This enables the rest of the code to only have to handle those two cases.
     """
     if isinstance(model_or_class, type) and issubclass(model_or_class, BaseType):
         return model_or_class()

transmute_core/tests/test_schematics.py

@@ -14,6 +14,7 @@
 from schematics.types.compound import DictType, ModelType
 from schematics.exceptions import ValidationError
 from transmute_core.exceptions import SerializationException, NoSerializerFound
+from transmute_core.object_serializers.schematics_serializer import SchematicsSerializer
 
 
 class Card(Model):
@@ -85,8 +86,7 @@ def test_schematics_to_json_schema(object_serializer_set):
         (IntType, {"type": "integer"}),
         (datetime, {"type": "string", "format": "date-time"}),
         (UTCDateTimeType, {"type": "string", "format": "date-time"}),
-        (Serializable(fget=lambda: None,
-                      type=StringType()), {"type": "string"}),
+        (Serializable(fget=lambda: None, type=StringType()), {"type": "string"}),
     ],
 )
 def test_to_json_schema(object_serializer_set, inp, expected):
@@ -165,3 +165,27 @@ def test_can_handle(object_serializer_set, cls, should_handle):
     the object serializer set should not raise an exception if it can handle these types.
     """
     object_serializer_set[cls]
+
+
+def test_schematics_uses_cached_entries():
+    """
+    Regression test. Validating that SchematicsSerializer uses the
+    same json schema it used previously, as before erroneous
+    use of the instantiated model as a key was causing memory leaks.
+    """
+    serializer = SchematicsSerializer()
+    # A nested schema type is required as primitives have
+    # hard-coded dictionaries representing the json.
+    class SchematicsBody(Model):
+        name = StringType(max_length=5)
+
+    # ensure that instances have the same key as well.
+    instance = ModelType(SchematicsBody)
+    original_payload = serializer.to_json_schema(instance)
+    second_payload = serializer.to_json_schema(instance)
+    assert original_payload is second_payload
+
+    # classes are also valid output to recieve that the json schema
+    original_payload = serializer.to_json_schema(SchematicsBody)
+    second_payload = serializer.to_json_schema(SchematicsBody)
+    assert original_payload is second_payload

uranium

@@ -9,9 +9,8 @@ ROOT = os.path.dirname(__file__)
 URANIUM_GITHUB_ACCOUNT = os.getenv("URANIUM_GITHUB_ACCOUNT", "toumorokoshi")
 URANIUM_GITHUB_BRANCH = os.getenv("URANIUM_GITHUB_BRANCH", "master")
 URANIUM_STANDALONE_URL = "https://raw.githubusercontent.com/{account}/uranium/{branch}/uranium/scripts/uranium_standalone".format(
-    account=URANIUM_GITHUB_ACCOUNT, branch=URANIUM_GITHUB_BRANCH
-)
-CACHE_DIRECTORY = os.path.join(ROOT, ".env", ".uranium")
+    account=URANIUM_GITHUB_ACCOUNT, branch=URANIUM_GITHUB_BRANCH)
+CACHE_DIRECTORY = os.path.join(ROOT, ".virtualenv", ".uranium")
 CACHED_URANIUM_STANDALONE = os.path.join(CACHE_DIRECTORY, "uranium_standalone")
 # set uranium to use to 2.0a0
 os.environ["URANIUM_VERSION"] = "2.0a1"