Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

from vcr.serializers import compat 

from vcr.request import Request 

import yaml 

 

# version 1 cassettes started with VCR 1.0.x. 

# Before 1.0.x, there was no versioning. 

CASSETTE_FORMAT_VERSION = 1 

 

""" 

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 _looks_like_an_old_cassette(data): 

    return isinstance(data, list) and len(data) and 'request' in data[0] 

 

 

def _warn_about_old_cassette_format(): 

    raise ValueError( 

        "Your cassette files were generated in an older version " 

        "of VCR. Delete your cassettes or run the migration script." 

        "See http://git.io/mHhLBg for more details." 

    ) 

 

 

def deserialize(cassette_string, serializer): 

    try: 

        data = serializer.deserialize(cassette_string) 

    # Old cassettes used to use yaml object thingy so I have to 

    # check for some fairly stupid exceptions here 

    except (ImportError, yaml.constructor.ConstructorError): 

        _warn_about_old_cassette_format() 

    if _looks_like_an_old_cassette(data): 

        _warn_about_old_cassette_format() 

 

    requests = [Request._from_dict(r['request']) for r in data['interactions']] 

    responses = [ 

        compat.convert_to_bytes(r['response']) for r in data['interactions'] 

    ] 

    return requests, responses 

 

 

def serialize(cassette_dict, serializer): 

    interactions = ([{ 

        'request': request._to_dict(), 

        'response': compat.convert_to_unicode(response), 

    } for request, response in zip( 

        cassette_dict['requests'], 

        cassette_dict['responses'], 

    )]) 

    data = { 

        'version': CASSETTE_FORMAT_VERSION, 

        'interactions': interactions, 

    } 

    return serializer.serialize(data)