New release 2.0.2

.travis.yml

@@ -10,6 +10,8 @@ install:
     - pip install -r test_requirements.txt
 before_install:
     - export DEVICE_HIVE_TRANSPORT_URLS='http://playground.dev.devicehive.com/api/rest,ws://playground.dev.devicehive.com/api/websocket'
-    - openssl aes-256-cbc -K $encrypted_1ea9ebbf5537_key -iv $encrypted_1ea9ebbf5537_iv -in refresh_token.txt.enc -out refresh_token.txt -d
-    - export DEVICE_HIVE_REFRESH_TOKEN=$(cat refresh_token.txt)
-script: pytest -xv tests --transport-urls=$DEVICE_HIVE_TRANSPORT_URLS --refresh-token=$DEVICE_HIVE_REFRESH_TOKEN
+    - openssl aes-256-cbc -K $encrypted_1ea9ebbf5537_key -iv $encrypted_1ea9ebbf5537_iv -in admin_refresh_token.txt.enc -out admin_refresh_token.txt -d
+    - export DEVICE_HIVE_ADMIN_REFRESH_TOKEN=$(cat admin_refresh_token.txt)
+    - openssl aes-256-cbc -K $encrypted_94dc46d8330a_key -iv $encrypted_94dc46d8330a_iv -in user_refresh_token.txt.enc -out user_refresh_token.txt -d
+    - export DEVICE_HIVE_USER_REFRESH_TOKEN=$(cat user_refresh_token.txt)
+script: pytest -xv tests --transport-urls=$DEVICE_HIVE_TRANSPORT_URLS --admin-refresh-token=$DEVICE_HIVE_ADMIN_REFRESH_TOKEN --user-refresh-token=$DEVICE_HIVE_USER_REFRESH_TOKEN

README.md

@@ -117,7 +117,7 @@ If you want to use `Websocket` protocol you need only to specify the url:
 url = 'ws://playground.dev.devicehive.com/api/websocket'
 ```
 
-### Authentication.
+### Authentication
 
 There are three ways of initial authentication:
 
@@ -474,7 +474,7 @@ class SimpleHandler(Handler):
         self.api.disconnect()
 ```
 
-## Extended example:
+## Extended example
 
 Here we will create one endpoint which sends notifications and other endpoint 
 which receives these notifications.

devicehive/api_handler.py

@@ -16,7 +16,7 @@ class ApiHandler(Handler):
 
     def __init__(self, transport, auth, handler_class, handler_args,
                  handler_kwargs):
-        Handler.__init__(self, transport)
+        super(ApiHandler, self).__init__(transport)
         self._api = Api(self._transport, auth)
         self._handler = handler_class(self._api, *handler_args,
                                       **handler_kwargs)

devicehive/api_request.py

@@ -2,6 +2,10 @@
 from devicehive.api_response import ApiResponseError
 from devicehive.transports.transport import TransportError
 import uuid
+import logging
+
+
+logger = logging.getLogger(__name__)
 
 
 class ApiRequest(object):
@@ -81,10 +85,16 @@ def response_key(self, key):
         self._params['response_key'] = key
 
     def execute(self, error_message):
-        response = self._api.transport.request(self._uuid(), self._action,
-                                               self._request.copy(),
+        uuid = self._uuid()
+        request = self._request.copy()
+        logger.debug('Request id: %s. Action: %s. Request: %s.', uuid,
+                     self._action, request)
+        response = self._api.transport.request(uuid, self._action, request,
                                                **self._params)
         api_response = ApiResponse(response, self._params['response_key'])
+        logger.debug('Response id: %s. Action: %s. Success: %s. Response: %s.',
+                     api_response.id, api_response.action, api_response.success,
+                     api_response.response)
         if api_response.success:
             return api_response.response
         raise ApiResponseError(error_message, self._api.transport.name,
@@ -97,13 +107,13 @@ class AuthApiRequest(ApiRequest):
     def execute(self, error_message):
         self.header(*self._api.token.auth_header)
         try:
-            return ApiRequest.execute(self, error_message)
+            return super(AuthApiRequest, self).execute(error_message)
         except ApiResponseError as api_response_error:
             if api_response_error.code != 401:
                 raise
         self._api.token.auth()
         self.header(*self._api.token.auth_header)
-        return ApiRequest.execute(self, error_message)
+        return super(AuthApiRequest, self).execute(error_message)
 
 
 class SubscriptionApiRequest(object):
@@ -170,7 +180,7 @@ class AuthSubscriptionApiRequest(SubscriptionApiRequest):
     """Auth subscription api request class."""
 
     def __init__(self, api):
-        SubscriptionApiRequest.__init__(self)
+        super(AuthSubscriptionApiRequest, self).__init__()
         auth_header_name, auth_header_value = api.token.auth_header
         self._params['headers'][auth_header_name] = auth_header_value
         self._params['response_error_handler'] = self.response_error_handler

devicehive/api_response.py

@@ -54,7 +54,7 @@ def __init__(self, message, transport_name, code, error):
         message = '%s Transport: %s. Code: %s. Error: %s' % (message,
                                                              transport_name,
                                                              code, error)
-        Exception.__init__(self, message)
+        super(ApiResponseError, self).__init__(message)
         self._transport_name = transport_name
         self._code = code
         self._error = error

devicehive/data_formats/json_data_format.py

@@ -6,7 +6,7 @@ class JsonDataFormat(DataFormat):
     """Json data format class."""
 
     def __init__(self):
-        DataFormat.__init__(self, 'json', self.TEXT_DATA_TYPE)
+        super(JsonDataFormat, self).__init__('json', self.TEXT_DATA_TYPE)
 
     def encode(self, data):
         return json.dumps(data)

devicehive/device_hive.py

@@ -39,6 +39,7 @@ def connect(self, transport_url, **options):
         connect_timeout = options.pop('connect_timeout', 30)
         max_num_connect = options.pop('max_num_connect', 10)
         connect_interval = options.pop('connect_interval', 1)
+        transport_alive_timeout = options.pop('transport_alive_timeout', 0.01)
         self._api_handler_options['auth'] = auth
         self._init_transport()
         connect_time = time.time()
@@ -47,7 +48,8 @@ def connect(self, transport_url, **options):
             if self._transport.connected:
                 self._transport.disconnect()
             self._transport.connect(transport_url, **options)
-            self._transport.join()
+            while self._transport.is_alive():
+                time.sleep(transport_alive_timeout)
             exception_info = self._transport.exception_info
             if exception_info and not isinstance(exception_info[1],
                                                  self._transport.error):

devicehive/transports/http_transport.py

@@ -11,8 +11,10 @@ class HttpTransport(Transport):
 
     def __init__(self, data_format_class, data_format_options, handler_class,
                  handler_options):
-        Transport.__init__(self, 'http', HttpTransportError, data_format_class,
-                           data_format_options, handler_class, handler_options)
+        super(HttpTransport, self).__init__('http', HttpTransportError,
+                                            data_format_class,
+                                            data_format_options, handler_class,
+                                            handler_options)
         self._url = None
         self._options = None
         self._events_queue_timeout = None

devicehive/transports/transport.py

@@ -108,6 +108,9 @@ def disconnect(self):
     def join(self, timeout=None):
         self._connection_thread.join(timeout)
 
+    def is_alive(self):
+        return self._connection_thread.is_alive()
+
     def send_request(self, request_id, action, request, **params):
         raise NotImplementedError
 

devicehive/transports/websocket_transport.py

@@ -11,9 +11,11 @@ class WebsocketTransport(Transport):
 
     def __init__(self, data_format_class, data_format_options, handler_class,
                  handler_options):
-        Transport.__init__(self, 'websocket', WebsocketTransportError,
-                           data_format_class, data_format_options,
-                           handler_class, handler_options)
+        super(WebsocketTransport, self).__init__('websocket',
+                                                 WebsocketTransportError,
+                                                 data_format_class,
+                                                 data_format_options,
+                                                 handler_class, handler_options)
         self._websocket = websocket.WebSocket()
         self._pong_received = False
         self._event_queue = []

examples/echo.py

@@ -1,11 +1,32 @@
 from devicehive import Handler
 from devicehive import DeviceHive
+import logging.config
+
+
+LOGGING = {
+    'version': 1,
+    'handlers': {
+        'console': {
+            'level': 'DEBUG',
+            'class': 'logging.StreamHandler',
+        },
+    },
+    'loggers': {
+        'devicehive.api_request': {
+            'handlers': ['console'],
+            'level': 'DEBUG',
+            'propagate': False
+        },
+    }
+}
+
+logging.config.dictConfig(LOGGING)
 
 
 class EchoHandler(Handler):
 
     def __init__(self, api, device_id='example-echo-device'):
-        Handler.__init__(self, api)
+        super(EchoHandler, self).__init__(api)
         self._device_id = device_id
         self._device = None
 

examples/raspi_led_thermo.py

@@ -65,7 +65,7 @@ class SampleHandler(Handler):
     INTERVAL_SECONDS = 5
 
     def __init__(self, api, device_id=DEVICE_ID):
-        Handler.__init__(self, api)
+        super(SampleHandler, self).__init__(api)
         self._device_id = device_id
         self._device = None
         self._sensor = TempSensor()

setup.py

@@ -7,7 +7,7 @@
 
 
 setup(name='devicehive',
-      version='2.0.1',
+      version='2.0.2',
       author='DataArt (http://dataart.com)',
       author_email='info@devicehive.com',
       url='https://devicehive.com',

tests/conftest.py

@@ -3,17 +3,24 @@
 
 def pytest_addoption(parser):
     parser.addoption('--transport-urls', action='store', help='Transport urls')
-    parser.addoption('--refresh-token', action='store', help='Refresh token')
+    parser.addoption('--admin-refresh-token', action='store',
+                     help='Admin refresh tokens')
+    parser.addoption('--user-refresh-token', action='store',
+                     help='User refresh tokens')
 
 
 def pytest_generate_tests(metafunc):
     if metafunc.module.__name__.find('.test_api') == -1:
         return
     transport_urls = metafunc.config.option.transport_urls.split(',')
-    refresh_token = metafunc.config.option.refresh_token
+    refresh_tokens = {'admin': metafunc.config.option.admin_refresh_token,
+                      'user': metafunc.config.option.user_refresh_token}
     tests = []
     ids = []
     for transport_url in transport_urls:
-        tests.append(Test(transport_url, refresh_token))
-        ids.append(transport_url)
+        for token_type, refresh_token in refresh_tokens.items():
+            if not refresh_token:
+                continue
+            tests.append(Test(transport_url, refresh_token, token_type))
+            ids.append('%s:%s' % (token_type, transport_url))
     metafunc.parametrize('test', tests, ids=ids)

tests/test.py

@@ -9,7 +9,7 @@ class TestHandler(Handler):
 
     def __init__(self, api, handle_connect, handle_command_insert,
                  handle_command_update, handle_notification):
-        Handler.__init__(self, api)
+        super(TestHandler, self).__init__(api)
         self._handle_connect = handle_connect
         self._handle_command_insert = handle_command_insert
         self._handle_command_update = handle_command_update
@@ -44,16 +44,19 @@ def disconnect(self):
 class Test(object):
     """Test class."""
 
-    def __init__(self, transport_url, refresh_token):
+    def __init__(self, transport_url, refresh_token, token_type):
         self._transport_url = transport_url
         self._refresh_token = refresh_token
+        self._token_type = token_type
         self._transport_name = DeviceHive.transport_name(self._transport_url)
 
     def generate_id(self, key=None):
         time_key = repr(time.time())
         if not key:
-            return '%s-%s' % (self._transport_name, time_key)
-        return '%s-%s-%s' % (self._transport_name, key, time_key)
+            return '%s-%s-%s' % (self._transport_name, self._token_type,
+                                 time_key)
+        return '%s-%s-%s-%s' % (self._transport_name, key, self._token_type,
+                                time_key)
 
     @property
     def transport_name(self):
@@ -67,6 +70,24 @@ def http_transport(self):
     def websocket_transport(self):
         return self._transport_name == 'websocket'
 
+    @property
+    def user_refresh_token(self):
+        return self._token_type == 'user'
+
+    @property
+    def admin_refresh_token(self):
+        return self._token_type == 'admin'
+
+    def only_user_implementation(self):
+        if self.user_refresh_token:
+            return
+        pytest.skip('Implemented only for user refresh token.')
+
+    def only_admin_implementation(self):
+        if self.admin_refresh_token:
+            return
+        pytest.skip('Implemented only for admin refresh token.')
+
     def only_http_implementation(self):
         if self.http_transport:
             return