cleaned up style

Author: callum-oakley

pusher/client.py

@@ -1,13 +1,20 @@
 # -*- coding: utf-8 -*-
 
-from .util import ensure_text, app_id_re
+from __future__ import (
+    print_function,
+    unicode_literals,
+    absolute_import,
+    division)
+
+from pusher.util import ensure_text, app_id_re
 
 import six
 
 class Client(object):
-
-    def __init__(self, app_id, key, secret, ssl=True, host=None, port=None, timeout=5, cluster=None,
-                                json_encoder=None, json_decoder=None, backend=None, **backend_options):
+    def __init__(
+            self, app_id, key, secret, ssl=True, host=None, port=None,
+            timeout=5, cluster=None, json_encoder=None, json_decoder=None,
+            backend=None, **backend_options):
         if backend is None:
               from .requests import RequestsBackend
               backend = RequestsBackend
@@ -21,14 +28,17 @@ def __init__(self, app_id, key, secret, ssl=True, host=None, port=None, timeout=
 
         if not isinstance(ssl, bool):
               raise TypeError("SSL should be a boolean")
+
         self._ssl = ssl
 
         if port and not isinstance(port, six.integer_types):
               raise TypeError("port should be an integer")
+
         self._port = port or (443 if ssl else 80)
 
         if not isinstance(timeout, six.integer_types):
               raise TypeError("timeout should be an integer")
+
         self._timeout = timeout
         self._json_encoder = json_encoder
         self._json_decoder = json_decoder

pusher/pusher.py

@@ -1,14 +1,22 @@
 # -*- coding: utf-8 -*-
 
-from __future__ import (print_function, unicode_literals, absolute_import,
-                        division)
-from pusher.http import GET, POST, Request, request_method
+from __future__ import (
+    print_function,
+    unicode_literals,
+    absolute_import,
+    division)
+
+from pusher.util import (
+    ensure_text,
+    validate_channel,
+    validate_socket_id,
+    pusher_url_re,
+    channel_name_re)
+
 from pusher.signature import sign, verify
-from pusher.util import ensure_text, validate_channel, validate_socket_id, pusher_url_re, channel_name_re, join_attributes
 from pusher.pusher_client import PusherClient
 from pusher.notification_client import NotificationClient
 
-
 import collections
 import hashlib
 import json
@@ -33,22 +41,22 @@ class Pusher(object):
     :param timeout: Request timeout (in seconds)
     :param cluster: Convention for other clusters than the main Pusher-one.
       Eg: 'eu' will resolve to the api-eu.pusherapp.com host
-    :param backend: an http adapter class (AsyncIOBackend, RequestsBackend, SynchronousBackend, TornadoBackend)
+    :param backend: an http adapter class (AsyncIOBackend, RequestsBackend,
+      SynchronousBackend, TornadoBackend)
     :param backend_options: additional backend
     """
-    def __init__(self, app_id, key, secret, ssl=True, host=None, port=None, timeout=5, cluster=None,
-                 json_encoder=None, json_decoder=None, backend=None, notification_host=None,
-                 notification_ssl=True, **backend_options):
+    def __init__(
+            self, app_id, key, secret, ssl=True, host=None, port=None,
+            timeout=5, cluster=None, json_encoder=None, json_decoder=None,
+            backend=None, notification_host=None, notification_ssl=True,
+            **backend_options):
         self._pusher_client = PusherClient(
-            app_id, key, secret, ssl,
-            host, port, timeout, cluster,
-            json_encoder, json_decoder, backend,
-            **backend_options)
+            app_id, key, secret, ssl, host, port, timeout, cluster,
+            json_encoder, json_decoder, backend, **backend_options)
 
         self._notification_client = NotificationClient(
-            app_id, key, secret, notification_ssl,
-            notification_host, port, timeout, cluster,
-            json_encoder, json_decoder, backend,
+            app_id, key, secret, notification_ssl, notification_host, port,
+            timeout, cluster, json_encoder, json_decoder, backend,
             **backend_options)
 
 
@@ -61,20 +69,22 @@ def from_url(cls, url, **options):
         Usage::
 
           >> from pusher import Pusher
-          >> p = Pusher.from_url("http://mykey:mysecret@api.pusher.com/apps/432")
+          >> p =
+            Pusher.from_url("http://mykey:mysecret@api.pusher.com/apps/432")
         """
         m = pusher_url_re.match(ensure_text(url, "url"))
         if not m:
             raise Exception("Unparsable url: %s" % url)
+
         ssl = m.group(1) == 'https'
 
         options_ = {
             'key': m.group(2),
             'secret': m.group(3),
             'host': m.group(4),
             'app_id': m.group(5),
-            'ssl': ssl,
-        }
+            'ssl': ssl}
+
         options_.update(options)
 
         return cls(**options_)
@@ -106,7 +116,8 @@ def trigger(self, channels, event_name, data, socket_id=None):
 
         http://pusher.com/docs/rest_api#method-post-event
         '''
-        return self._pusher_client.trigger(channels, event_name, data, socket_id)
+        return self._pusher_client.trigger(
+            channels, event_name, data, socket_id)
 
 
     def trigger_batch(self, batch=[], already_encoded=False):
@@ -144,6 +155,11 @@ def users_info(self, channel):
         '''
         return self._pusher_client.users_info(channel)
 
+
+    def notify(self, interest, notification):
+        return self._notification_client.notify(interest, notification)
+
+
     def authenticate(self, channel, socket_id, custom_data=None):
         """Used to generate delegated client subscription token.
 
@@ -176,6 +192,7 @@ def authenticate(self, channel, socket_id, custom_data=None):
 
         return result
 
+
     def validate_webhook(self, key, signature, body):
         """Used to validate incoming webhook messages. When used it guarantees
         that the sender is Pusher and not someone else impersonating it.
@@ -207,12 +224,3 @@ def validate_webhook(self, key, signature, body):
             return None
 
         return body_data
-
-    def notify(self, interest, notification):
-        return self._notification_client.notify(interest, notification)
-
-    def _data_to_string(self, data):
-        if isinstance(data, six.string_types):
-            return ensure_text(data, "data")
-        else:
-            return json.dumps(data, cls=self._json_encoder)

pusher/pusher_client.py

@@ -1,13 +1,21 @@
 # -*- coding: utf-8 -*-
 
-from __future__ import (print_function, unicode_literals, absolute_import,
-                        division)
+from __future__ import (
+    print_function,
+    unicode_literals,
+    absolute_import,
+    division)
+
+from pusher.util import (
+    ensure_text,
+    validate_channel,
+    validate_socket_id,
+    join_attributes,
+    data_to_string)
+
 from pusher.http import GET, POST, Request, request_method
-from pusher.signature import sign, verify
-from pusher.util import ensure_text, validate_channel, validate_socket_id, pusher_url_re, channel_name_re, join_attributes
 from pusher.client import Client
 
-
 import collections
 import hashlib
 import json
@@ -18,19 +26,22 @@
 
 
 class PusherClient(Client):
-    def __init__(self, app_id, key, secret, ssl=True, host=None, port=None, timeout=5, cluster=None,
-                 json_encoder=None, json_decoder=None, backend=None, notification_host=None,
-                 notification_ssl=True, **backend_options):
+    def __init__(
+            self, app_id, key, secret, ssl=True, host=None, port=None,
+            timeout=5, cluster=None, json_encoder=None, json_decoder=None,
+            backend=None, notification_host=None, notification_ssl=True,
+            **backend_options):
         super(PusherClient, self).__init__(
-            app_id, key, secret, ssl,
-            host, port, timeout, cluster,
-            json_encoder, json_decoder, backend,
-            **backend_options)
+            app_id, key, secret, ssl, host, port, timeout, cluster,
+            json_encoder, json_decoder, backend, **backend_options)
 
         if host:
             self._host = ensure_text(host, "host")
+
         elif cluster:
-            self._host = six.text_type("api-%s.pusher.com") % ensure_text(cluster, "cluster")
+            self._host = six.text_type("api-%s.pusher.com") %
+                ensure_text(cluster, "cluster")
+
         else:
             self._host = six.text_type("api.pusherapp.com")
 
@@ -40,7 +51,8 @@ def trigger(self, channels, event_name, data, socket_id=None):
         if isinstance(channels, six.string_types):
             channels = [channels]
 
-        if isinstance(channels, dict) or not isinstance(channels, (collections.Sized, collections.Iterable)):
+        if isinstance(channels, dict) or not isinstance(
+                channels, (collections.Sized, collections.Iterable)):
             raise TypeError("Expected a single or a list of channels")
 
         if len(channels) > 10:
@@ -53,16 +65,16 @@ def trigger(self, channels, event_name, data, socket_id=None):
         if len(event_name) > 200:
             raise ValueError("event_name too long")
 
-        data = self._data_to_string(data)
+        data = data_to_string(data, self._json_encoder)
 
         if len(data) > 10240:
             raise ValueError("Too much data")
 
         params = {
             'name': event_name,
             'channels': channels,
-            'data': data
-        }
+            'data': data}
+
         if socket_id:
             params['socket_id'] = validate_socket_id(socket_id)
 
@@ -79,13 +91,14 @@ def trigger_batch(self, batch=[], already_encoded=False):
 
         if not already_encoded:
             for event in batch:
-                event['data'] = self._data_to_string(event['data'])
+                event['data'] = data_to_string(event['data'],
+                self._json_encoder)
 
         params = {
-            'batch': batch
-        }
+            'batch': batch}
 
-        return Request(self, POST, "/apps/%s/batch_events" % self.app_id, params)
+        return Request(
+            self, POST, "/apps/%s/batch_events" % self.app_id, params)
 
 
     @request_method
@@ -98,9 +111,13 @@ def channels_info(self, prefix_filter=None, attributes=[]):
         params = {}
         if attributes:
             params['info'] = join_attributes(attributes)
+
         if prefix_filter:
-            params['filter_by_prefix'] = ensure_text(prefix_filter, "prefix_filter")
-        return Request(self, GET, six.text_type("/apps/%s/channels") % self.app_id, params)
+            params['filter_by_prefix'] = ensure_text(
+                prefix_filter, "prefix_filter")
+
+        return Request(
+            self, GET, six.text_type("/apps/%s/channels") % self.app_id, params)
 
 
     @request_method
@@ -115,7 +132,9 @@ def channel_info(self, channel, attributes=[]):
         params = {}
         if attributes:
             params['info'] = join_attributes(attributes)
-        return Request(self, GET, "/apps/%s/channels/%s" % (self.app_id, channel), params)
+
+        return Request(
+            self, GET, "/apps/%s/channels/%s" % (self.app_id, channel), params)
 
 
     @request_method
@@ -127,77 +146,5 @@ def users_info(self, channel):
         '''
         validate_channel(channel)
 
-        return Request(self, GET, "/apps/%s/channels/%s/users" % (self.app_id, channel))
-
-
-    def authenticate(self, channel, socket_id, custom_data=None):
-        """Used to generate delegated client subscription token.
-
-        :param channel: name of the channel to authorize subscription to
-        :param socket_id: id of the socket that requires authorization
-        :param custom_data: used on presence channels to provide user info
-        """
-        channel = validate_channel(channel)
-
-        if not channel_name_re.match(channel):
-            raise ValueError('Channel should be a valid channel, got: %s' % channel)
-
-        socket_id = validate_socket_id(socket_id)
-
-        if custom_data:
-            custom_data = json.dumps(custom_data, cls=self._json_encoder)
-
-        string_to_sign = "%s:%s" % (socket_id, channel)
-
-        if custom_data:
-            string_to_sign += ":%s" % custom_data
-
-        signature = sign(self.secret, string_to_sign)
-
-        auth = "%s:%s" % (self.key, signature)
-        result = {'auth': auth}
-
-        if custom_data:
-            result['channel_data'] = custom_data
-
-        return result
-
-
-    def validate_webhook(self, key, signature, body):
-        """Used to validate incoming webhook messages. When used it guarantees
-        that the sender is Pusher and not someone else impersonating it.
-
-        :param key: key used to sign the body
-        :param signature: signature that was given with the body
-        :param body: content that needs to be verified
-        """
-        key = ensure_text(key, "key")
-        signature = ensure_text(signature, "signature")
-        body = ensure_text(body, "body")
-
-        if key != self.key:
-            return None
-
-        if not verify(self.secret, body, signature):
-            return None
-
-        try:
-            body_data = json.loads(body, cls=self._json_decoder)
-        except ValueError:
-            return None
-
-        time_ms = body_data.get('time_ms')
-        if not time_ms:
-            return None
-
-        if abs(time.time()*1000 - time_ms) > 300000:
-            return None
-
-        return body_data
-
-
-    def _data_to_string(self, data):
-        if isinstance(data, six.string_types):
-            return ensure_text(data, "data")
-        else:
-            return json.dumps(data, cls=self._json_encoder)
+        return Request(
+            self, GET, "/apps/%s/channels/%s/users" % (self.app_id, channel))