|  |  | 
__builtin__.object
Jsonc
 
 
| class Jsonc(__builtin__.object)
 |  |  | Represents JSON-C data in an easy to access object format. 
 To access the members of a JSON structure which looks like this:
 {
 "data": {
 "totalItems": 800,
 "items": [
 {
 "content": {
 "1": "rtsp://v5.cache3.c.youtube.com/CiILENy.../0/0/0/video.3gp"
 },
 "viewCount": 220101,
 "commentCount": 22,
 "favoriteCount": 201
 }
 ]
 },
 "apiVersion": "2.0"
 }
 
 You would do the following:
 x = gdata.core.parse_json(the_above_string)
 # Gives you 800
 x.data.total_items
 # Should be 22
 x.data.items[0].comment_count
 # The apiVersion is '2.0'
 x.api_version
 
 To create a Jsonc object which would produce the above JSON, you would do:
 gdata.core.Jsonc(
 api_version='2.0',
 data=gdata.core.Jsonc(
 total_items=800,
 items=[
 gdata.core.Jsonc(
 view_count=220101,
 comment_count=22,
 favorite_count=201,
 content={
 '1': ('rtsp://v5.cache3.c.youtube.com'
 '/CiILENy.../0/0/0/video.3gp')})]))
 or
 x = gdata.core.Jsonc()
 x.api_version = '2.0'
 x.data = gdata.core.Jsonc()
 x.data.total_items = 800
 x.data.items = []
 # etc.
 
 How it works:
 The JSON-C data is stored in an internal dictionary (._dict) and the
 getattr, setattr, and delattr methods rewrite the name which you provide
 to mirror the expected format in JSON-C. (For more details on name
 conversion see _to_jsonc_name.) You may also access members using
 getitem, setitem, delitem as you would for a dictionary. For example
 x.data.total_items is equivalent to x['data']['totalItems']
 (Not all dict methods are supported so if you need something other than
 the item operations, then you will want to use the ._dict member).
 
 You may need to use getitem or the _dict member to access certain
 properties in cases where the JSON-C syntax does not map neatly to Python
 objects. For example the YouTube Video feed has some JSON like this:
 "content": {"1": "rtsp://v5.cache3.c.youtube.com..."...}
 You cannot do x.content.1 in Python, so you would use the getitem as
 follows:
 x.content['1']
 or you could use the _dict member as follows:
 x.content._dict['1']
 
 If you need to create a new object with such a mapping you could use.
 
 x.content = gdata.core.Jsonc(_dict={'1': 'rtsp://cache3.c.youtube.com...'})
 
 |  |  | Methods defined here: 
 __delattr__(self, name)
 __delitem__(self, key)
 __getattr__(self, name)
 __getitem__(self, key)# For container methods pass-through to the underlying dict.
 __init__(self, _dict=None, **kwargs)
 __setattr__(self, name, value)
 __setitem__(self, key, value)
 Data descriptors defined here:
 
 __dict__dictionary for instance variables (if defined)
 __weakref__list of weak references to the object (if defined)
 |  |