Rearranging architecture

web3/web3/IPCProvider.py

@@ -20,15 +20,15 @@ def getDefaultIPCPath():
 
 class IPCProvider(Provider):
 
-    def __init__(self, ipcpath=None):
+    def __init__(self, ipcpath=None, *args, **kwargs):
         if path is None:
             self.ipcpath = getDefaultIPCPath()
         else:
             self.ipcpath = path
 
         self.socket = self.getSocket()
 
-        super(IPCProvider, self).__init__()
+        super(IPCProvider, self).__init__(*args, **kwargs)
 
     def getSocket(self):
         socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)

web3/web3/method.py

@@ -5,11 +5,11 @@
 class Method(object):
 
     def __init__(self, options):
-        self.name = options["name"]
-        self.call = options["call"]
-        self.params = options["params"] if "params" in options else 0
-        self.inputFormatter = options["inputFormatter"]
-        self.outputFormatter = options["outputFormatter"]
+        self.name = options.get("name")
+        self.call = options.get("call")
+        self.params = options.get("params", 0)
+        self.inputFormatter = options.get("inputFormatter")
+        self.outputFormatter = options.get("outputFormatter")
         self.requestManager = None
 
     def setRequestManager(self, rm):
@@ -25,17 +25,6 @@ def getCall(self, args):
         """
         return self.call(args) if utils.isFunction(self.call) else self.call
 
-    def extractCallback(self, args):
-        """
-        Should be used to extract callback from array of arguments. Modifies input param
-
-        @method extractCallback
-        @param {Array} arguments
-        @return {Function|Null} callback, if exists
-        """
-        if utils.isFunction(args[-1]):
-            return args[:-1]
-
     def validateArgs(self, args):
         """
         Should be called to check if the number of arguments is correct
@@ -80,36 +69,30 @@ def toPayload(self, args):
         @return {Object}
         """
         call = self.getCall(args)
-        callback = self.extractCallback(args)
         params = self.formatInput(args)
         self.validateArgs(params)
 
         return {
             "method": call,
             "params": params,
-            "callback": callback
         }
 
     def attachToObject(self, obj):
         func = self.buildCall()
         func.call = self.call
         name = self.name.split(".")
         if len(name) > 1:
-            obj[name[0]] = obj[name[0]] if name[0] in obj else {}
-            obj[name[0]][name[1]] = func
+            if not getattr(obj, name[0]):
+                setattr(obj, name[0], object())
+            setattr(getattr(obj, name[0]), name[1], func)
         else:
-            obj[name[0]] = func
+            setattr(obj, name[0], func)
 
     def buildCall(self):
-        method = self
 
         def send(*arguments):
-            payload = method.toPayload(list(arguments))
-            if "callback" in payload:
-                return method.requestManager.sendAsync(payload,
-                        lambda err, result: payload.callback(err, method.formatOutput(result)))
-
-            return method.formatOutput(method.requestManager.send(payload))
+            payload = self.toPayload(list(arguments))
+            return self.formatOutput(self.requestManager.send(payload, *arguments))
 
         send.request = self.request.bind(self)
         return send
@@ -123,5 +106,5 @@ def request(self, *arguments):
         @return {Object} jsonrpc request
         """
         payload = self.toPayload(list(arguments))
-        payload.format = self.formatOutput.bind(self)
+        payload["format"] = self.formatOutput
         return payload

web3/web3/property.py

@@ -13,7 +13,6 @@ def __init__(self, options):
     def setRequestManager(self, rm):
         self.requestManager = rm
 
-
     def formatInput(self, arg):
         """
         Should be called to format input args of method
@@ -26,15 +25,6 @@ def formatOutput(self, result):
         """
         return self.outputFormatter(result) if result and self.outputFormatter else result
 
-
-    def extractCallback(self, args):
-        """
-        Should be used to extract callback from array of arguments. Modifies input param
-        """
-        if utils.isFunction(args[-1]):
-            return args.pop()
-
-
     def attachToObject(self, obj):
         names = self.name.split(".")
         name = names[0]
@@ -43,37 +33,25 @@ def attachToObject(self, obj):
                 setattr(obj, names[0], object())
             obj = getattr(obj, names[0])
             name = names[1]
-        setattr(obj, asyncGetterName(name), self.buildGet())# buildAsyncGet()
-
+        setattr(obj, asyncGetterName(name), self.buildGet())
 
     def asyncGetterName(self, name):
         return "get" + name[0].upper() + name[1:]
 
     def buildGet():
-        def get():
+        def get(*arguments):
             return self.formatOutput(self.requestManager.send(
                 {
                 "method": self.getter
-                }
+                },
+                *arguments
                 ))
         return get
 
-
-    def buildAsyncGet():
-        def get(callback):
-            return self.requestManager.sendAsync(
-                {
-                "method": self.getter
-                }
-            )
-        return get
-
-
-    def request(*arguments):
+    def request():
         payload = {
             "method": self.getter,
             "params": [],
-            "callback": self.extractCallback(arguments)
         }
         payload["format"] = self.formatOutput(self)
         return payload

web3/web3/provider.py

@@ -20,7 +20,7 @@ def process_requests(self):
             except Exception as e:
                 response = e
 
-            self.responses[request["messageId"]] = response
+            self.responses[request["id"]] = response
 
     def _make_request(self, request):
         raise NotImplementedError("Providers must implement this method")

web3/web3/requestmanager.py

@@ -6,39 +6,40 @@ class RequestManager(object):
 
     def __init__(self, provider):
         self.provider = provider
+        self.reqid = 0
 
     def setProvider(self, provider):
         """Should be used to set provider of request manager"""
         self.provider = provider
 
     def send(self, data, timeout=None):
         """Should be used to synchronously send request"""
-        requestid = self.sendAsync(payload)
-        result = self.receiveAsync(requestid, timeout)
+        requestid = self.forward(payload)
 
-        if not Jsonrpc.isValidResponse(result):
-            raise errors.InvalidResponse(result)
+        if timeout == 0:
+            return requestid
+
+        result = self.receive(requestid, timeout)
 
         return result["result"]
 
-    def sendAsync(self, data):
+    def forward(self, data):
         """Should be used to asynchronously send request"""
         if not self.provider:
             raise errors.InvalidProvider()
 
-        payload = Jsonrpc.toPayload(data["method"], data["params"])
-        requestid = payload["messageId"]
-        self.provider.requests.put(payload)
+        reqid += 1
+        self.provider.requests.put(Jsonrpc.toPayload(reqid, data["method"], data["params"]))
 
-        return requestid
+        return reqid
 
-    def receiveAsync(self, requestid, timeout=0):
+    def receive(self, requestid, timeout=0):
         start = time.time()
 
         while True:
 
             if requestid in self.provider.responses:
-                return self.provider.pop(requestid)
+                return Jsonrpc.fromPayload(self.provider.pop(requestid))
 
             if timeout is not None and time.time()-start >= timeout:
                 if timeout == 0: