Make Serializers Dumber

Let's have the serializer just worry about serializing the dict
that we hand it, and move the unicode stuff up to a serialize module.

This should hopefully let us move toward using a version string in
cassettes.

vcr/serializers/jsonserializer.py

@@ -1,5 +1,3 @@
-from vcr.request import Request
-from . import compat
 try:
     import simplejson as json
 except ImportError:
@@ -7,26 +5,16 @@ except ImportError:
 
 
 def deserialize(cassette_string):
-    data = json.loads(cassette_string)
-    requests = [Request._from_dict(r['request']) for r in data]
-    responses = [compat.convert_to_bytes(r['response']) for r in data]
-    return requests, responses
+    return json.loads(cassette_string)
 
 
 def serialize(cassette_dict):
-    data = ([{
-        'request': request._to_dict(),
-        'response': compat.convert_to_unicode(response),
-    } for request, response in zip(
-        cassette_dict['requests'],
-        cassette_dict['responses']
-    )])
     try:
-        return json.dumps(data, indent=4)
+        return json.dumps(cassette_dict, indent=4)
     except UnicodeDecodeError:
         raise UnicodeDecodeError(
             "Error serializing cassette to JSON. ",
             "Does this HTTP interaction contain binary data? ",
-            "If so, use a different serializer (like the yaml serializer) for",
+            "If so, use a different serializer (like the yaml serializer) for ",
             "this request"
         )

vcr/serializers/yamlserializer.py

@@ -1,41 +1,14 @@
 import yaml
 
-from vcr.request import Request
-from . import compat
-
 # Use the libYAML versions if possible
 try:
     from yaml import CLoader as Loader, CDumper as Dumper
 except ImportError:
     from yaml import Loader, Dumper
 
-"""
-Just a general note on the serialization philosophy here:
-I prefer cassettes to be human-readable if possible.  Yaml serializes
-bytestrings to !!binary, which isn't readable, so I would like to serialize to
-strings and from strings, which yaml will encode as utf-8 automatically.
-All the internal HTTP stuff expects bytestrings, so this whole serialization
-process feels backwards.
-
-Serializing: bytestring -> string (yaml persists to utf-8)
-Deserializing: string (yaml converts from utf-8) -> bytestring
-"""
-
-
 def deserialize(cassette_string):
-    data = yaml.load(cassette_string, Loader=Loader)
-    requests = [Request._from_dict(r['request']) for r in data]
-    responses = [r['response'] for r in data]
-    responses = [compat.convert_to_bytes(r['response']) for r in data]
-    return requests, responses
+    return yaml.load(cassette_string, Loader=Loader)
 
 
 def serialize(cassette_dict):
-    data = ([{
-        'request': request._to_dict(),
-        'response': response,
-    } for request, response in zip(
-        cassette_dict['requests'],
-        [compat.convert_to_unicode(r) for r in cassette_dict['responses']],
-    )])
-    return yaml.dump(data, Dumper=Dumper)
+    return yaml.dump(cassette_dict, Dumper=Dumper)