This file is indexed.

/usr/lib/python2.7/dist-packages/jsonrpclib-0.1.7.egg-info is in python-jsonrpclib 0.1.7-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  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
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
Metadata-Version: 1.0
Name: jsonrpclib
Version: 0.1.7
Summary: This project is an implementation of the JSON-RPC v2.0 specification (backwards-compatible) as a client library.
Home-page: http://github.com/joshmarshall/jsonrpclib/
Author: Josh Marshall
Author-email: catchjosh@gmail.com
License: http://www.apache.org/licenses/LICENSE-2.0
Description: [![Build Status](https://travis-ci.org/joshmarshall/jsonrpclib.svg)](https://travis-ci.org/joshmarshall/jsonrpclib)
        
        JSONRPClib
        ==========
        This library is an implementation of the JSON-RPC specification.
        It supports both the original 1.0 specification, as well as the 
        new (proposed) 2.0 spec, which includes batch submission, keyword
        arguments, etc.
        
        It is licensed under the Apache License, Version 2.0
        (http://www.apache.org/licenses/LICENSE-2.0.html).
        
        Communication
        -------------
        Feel free to send any questions, comments, or patches to our Google Group 
        mailing list (you'll need to join to send a message): 
        http://groups.google.com/group/jsonrpclib
        
        Summary
        -------
        This library implements the JSON-RPC 2.0 proposed specification in pure Python. 
        It is designed to be as compatible with the syntax of xmlrpclib as possible 
        (it extends where possible), so that projects using xmlrpclib could easily be 
        modified to use JSON and experiment with the differences.
        
        It is backwards-compatible with the 1.0 specification, and supports all of the 
        new proposed features of 2.0, including:
        
        * Batch submission (via MultiCall)
        * Keyword arguments
        * Notifications (both in a batch and 'normal')
        * Class translation using the 'jsonclass' key.
        
        I've added a "SimpleJSONRPCServer", which is intended to emulate the 
        "SimpleXMLRPCServer" from the default Python distribution.
        
        Requirements
        ------------
        It supports cjson and simplejson, and looks for the parsers in that order 
        (searching first for cjson, then for the "built-in" simplejson as json in 2.6+, 
        and then the simplejson external library). One of these must be installed to 
        use this library, although if you have a standard distribution of 2.6+, you 
        should already have one. Keep in mind that cjson is supposed to be the 
        quickest, I believe, so if you are going for full-on optimization you may 
        want to pick it up.
        
        Installation
        ------------
        You can install this from PyPI with one of the following commands (sudo
        may be required):
        
        	easy_install jsonrpclib
        	pip install jsonrpclib
        
        Alternatively, you can download the source from the github repository
        at http://github.com/joshmarshall/jsonrpclib and manually install it
        with the following commands:
        
        	git clone git://github.com/joshmarshall/jsonrpclib.git
        	cd jsonrpclib
        	python setup.py install
        
        Client Usage
        ------------
        
        This is (obviously) taken from a console session.
        
        	>>> import jsonrpclib
        	>>> server = jsonrpclib.Server('http://localhost:8080')
        	>>> server.add(5,6)
        	11
        	>>> print jsonrpclib.history.request
        	{"jsonrpc": "2.0", "params": [5, 6], "id": "gb3c9g37", "method": "add"}
        	>>> print jsonrpclib.history.response
        	{'jsonrpc': '2.0', 'result': 11, 'id': 'gb3c9g37'}
        	>>> server.add(x=5, y=10)
        	15
        	>>> server._notify.add(5,6)
        	# No result returned...
        	>>> batch = jsonrpclib.MultiCall(server)
        	>>> batch.add(5, 6)
        	>>> batch.ping({'key':'value'})
        	>>> batch._notify.add(4, 30)
        	>>> results = batch()
        	>>> for result in results:
        	>>> ... print result
        	11
        	{'key': 'value'}
        	# Note that there are only two responses -- this is according to spec.
        
        If you need 1.0 functionality, there are a bunch of places you can pass that 
        in, although the best is just to change the value on 
        jsonrpclib.config.version:
        
        	>>> import jsonrpclib
        	>>> jsonrpclib.config.version
        	2.0
        	>>> jsonrpclib.config.version = 1.0
        	>>> server = jsonrpclib.Server('http://localhost:8080')
        	>>> server.add(7, 10)
        	17
        	>>> print jsonrpclib..history.request
        	{"params": [7, 10], "id": "thes7tl2", "method": "add"}
        	>>> print jsonrpclib.history.response
        	{'id': 'thes7tl2', 'result': 17, 'error': None}
        	>>> 
        
        The equivalent loads and dumps functions also exist, although with minor 
        modifications. The dumps arguments are almost identical, but it adds three 
        arguments: rpcid for the 'id' key, version to specify the JSON-RPC 
        compatibility, and notify if it's a request that you want to be a 
        notification. 
        
        Additionally, the loads method does not return the params and method like 
        xmlrpclib, but instead a.) parses for errors, raising ProtocolErrors, and 
        b.) returns the entire structure of the request / response for manual parsing.
        
        SimpleJSONRPCServer
        -------------------
        This is identical in usage (or should be) to the SimpleXMLRPCServer in the default Python install. Some of the differences in features are that it obviously supports notification, batch calls, class translation (if left on), etc. Note: The import line is slightly different from the regular SimpleXMLRPCServer, since the SimpleJSONRPCServer is distributed within the jsonrpclib library.
        
        	from jsonrpclib.SimpleJSONRPCServer import SimpleJSONRPCServer
        
        	server = SimpleJSONRPCServer(('localhost', 8080))
        	server.register_function(pow)
        	server.register_function(lambda x,y: x+y, 'add')
        	server.register_function(lambda x: x, 'ping')
        	server.serve_forever()
        
        Class Translation
        -----------------
        I've recently added "automatic" class translation support, although it is 
        turned off by default. This can be devastatingly slow if improperly used, so 
        the following is just a short list of things to keep in mind when using it.
        
        * Keep It (the object) Simple Stupid. (for exceptions, keep reading.)
        * Do not require init params (for exceptions, keep reading)
        * Getter properties without setters could be dangerous (read: not tested)
        
        If any of the above are issues, use the _serialize method. (see usage below)
        The server and client must BOTH have use_jsonclass configuration item on and 
        they must both have access to the same libraries used by the objects for 
        this to work.
        
        If you have excessively nested arguments, it would be better to turn off the 
        translation and manually invoke it on specific objects using 
        jsonrpclib.jsonclass.dump / jsonrpclib.jsonclass.load (since the default 
        behavior recursively goes through attributes and lists / dicts / tuples).
        
        [test_obj.py]
        
        	# This object is /very/ simple, and the system will look through the 
        	# attributes and serialize what it can.
        	class TestObj(object):
        	    foo = 'bar'
        
        	# This object requires __init__ params, so it uses the _serialize method
        	# and returns a tuple of init params and attribute values (the init params
        	# can be a dict or a list, but the attribute values must be a dict.)
        	class TestSerial(object):
        	    foo = 'bar'
        	    def __init__(self, *args):
        	        self.args = args
        	    def _serialize(self):
        	        return (self.args, {'foo':self.foo,})
        
        [usage]
        
        	import jsonrpclib
        	import test_obj
        
        	jsonrpclib.config.use_jsonclass = True
        
        	testobj1 = test_obj.TestObj()
        	testobj2 = test_obj.TestSerial()
        	server = jsonrpclib.Server('http://localhost:8080')
        	# The 'ping' just returns whatever is sent
        	ping1 = server.ping(testobj1)
        	ping2 = server.ping(testobj2)
        	print jsonrpclib.history.request
        	# {"jsonrpc": "2.0", "params": [{"__jsonclass__": ["test_obj.TestSerial", ["foo"]]}], "id": "a0l976iv", "method": "ping"}
        	print jsonrpclib.history.result
        	# {'jsonrpc': '2.0', 'result': <test_obj.TestSerial object at 0x2744590>, 'id': 'a0l976iv'}
        	
        To turn on this behaviour, just set jsonrpclib.config.use_jsonclass to True. 
        If you want to use a different method for serialization, just set 
        jsonrpclib.config.serialize_method to the method name. Finally, if you are 
        using classes that you have defined in the implementation (as in, not a 
        separate library), you'll need to add those (on BOTH the server and the 
        client) using the jsonrpclib.config.classes.add() method. 
        (Examples forthcoming.)
        
        Feedback on this "feature" is very, VERY much appreciated.
        
        Why JSON-RPC?
        -------------
        In my opinion, there are several reasons to choose JSON over XML for RPC:
        
        * Much simpler to read (I suppose this is opinion, but I know I'm right. :)
        * Size / Bandwidth - Main reason, a JSON object representation is just much smaller.
        * Parsing - JSON should be much quicker to parse than XML.
        * Easy class passing with jsonclass (when enabled)
        
        In the interest of being fair, there are also a few reasons to choose XML 
        over JSON:
        
        * Your server doesn't do JSON (rather obvious)
        * Wider XML-RPC support across APIs (can we change this? :))
        * Libraries are more established, i.e. more stable (Let's change this too.)
        
        TESTS
        -----
        I've dropped almost-verbatim tests from the JSON-RPC spec 2.0 page.
        You can run it with:
        
            pip install -r dev-requirements.txt
            nosetests tests.py
        
        TODO
        ----
        * Use HTTP error codes on SimpleJSONRPCServer
        * Test, test, test and optimize
        
Platform: UNKNOWN