cli2 3.3.25__tar.gz → 3.3.29__tar.gz

{cli2-3.3.25/cli2.egg-info → cli2-3.3.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cli2
-Version: 3.3.25
+Version: 3.3.29
 Summary: image:: https://yourlabs.io/oss/cli2/badges/master/pipeline.svg
 Home-page: https://yourlabs.io/oss/cli2
 Author: James Pic

{cli2-3.3.25 → cli2-3.3.29}/cli2/client.py

@@ -305,6 +305,11 @@ class Paginator:
                     break
                 page += 1
 
+    async def first(self):
+        """ Return first item """
+        async for item in self:
+            return item
+
 
 class Field:
     """
@@ -1027,12 +1032,13 @@ class Handler:
         self.tries = self.tries_default if tries is None else tries
         self.backoff = self.backoff_default if backoff is None else backoff
 
-    async def __call__(self, client, response, tries, mask):
+    async def __call__(self, client, response, tries, mask, log):
         if isinstance(response, Exception):
             if tries >= self.tries:
                 raise response
             # httpx session is rendered unusable after a TransportError
             if isinstance(response, httpx.TransportError):
+                log.warn('reconnect', exception=str(response))
                 await client.client_reset()
             return
 
@@ -1048,13 +1054,25 @@ class Handler:
         if tries >= self.tries:
             raise RetriesExceededError(client, response, tries, mask)
 
+        seconds = tries * self.backoff
+        kwargs = dict(
+            status_code=response.status_code,
+            tries=tries,
+            sleep=seconds,
+        )
+        key, value = client.response_log_data(response, mask)
+        if value:
+            kwargs[key] = value
+
         if response.status_code in self.retokens:
             if tries:
                 # our authentication is just not working, no need to retry
                 raise TokenGetError(client, response, tries, mask)
+            log.warn('retoken', **kwargs)
             await client.token_reset()
 
-        await asyncio.sleep(tries * self.backoff)
+        log.info('retry', **kwargs)
+        await asyncio.sleep(seconds)
 
 
 class ClientError(Exception):
@@ -1079,27 +1097,31 @@ class ResponseError(ClientError):
         :param exc: httpx.HTTPStatusError
         """
         output = [msg]
+        key, value = self.client.request_log_data(
+            self.response.request,
+            self.mask,
+        )
         request_msg = ' '.join([
-            self.response.request.method,
+            str(self.response.request.method),
             str(self.response.request.url),
         ])
 
         output.append(
             f'{colors.reset}{colors.bold}{request_msg}{colors.reset}',
         )
-        request = self.client.request_log_data(
-            self.response.request,
-            self.mask,
-        )
-        if request:
-            output.append(display.render(request))
+        if value:
+            output.append(display.render(value))
 
+        key, value = self.client.response_log_data(self.response, self.mask)
         output.append(
-            f'{colors.bold}HTTP {self.response.status_code}{colors.reset}',
+            ''.join([
+                colors.bold,
+                f'HTTP {self.response.status_code}',
+                colors.reset,
+            ])
         )
-        response = self.client.response_log_data(self.response, self.mask)
-        if response:
-            output.append(display.render(response))
+        if value:
+            output.append(display.render(value))
 
         return '\n'.join(output)
 
@@ -1217,7 +1239,10 @@ class Client(metaclass=ClientMetaclass):
         """
         client = httpx.AsyncClient(*self._client_args, **self._client_kwargs)
         if self.token and not self.token_getting:
-            self.client_token_apply(client)
+            try:
+                self.client_token_apply(client)
+            except NotImplementedError:
+                pass
         return client
 
     @client.setter
@@ -1228,27 +1253,34 @@ class Client(metaclass=ClientMetaclass):
     def client(self):
         self._client = None
 
-    async def request_safe(self, *args, handler, mask, retries=True,
-                           semaphore=None, **kwargs):
+    async def send(self, request, handler, mask, retries=True, semaphore=None,
+                   log=None, auth=None, follow_redirects=None):
         """
         Internal request method
         """
         semaphore = semaphore or self.semaphore
         tries = 0
 
+        async def _send():
+            return await self.client.send(
+                request,
+                auth=auth,
+                follow_redirects=follow_redirects,
+            )
+
         async def _request():
             if semaphore:
                 async with semaphore:
-                    return await self.client.request(*args, **kwargs)
-            return await self.client.request(*args, **kwargs)
+                    return await _send()
+            return await _send()
 
         while retries or tries > 1:
             try:
                 response = await _request()
             except Exception as exc:
-                await handler(self, exc, tries, mask)
+                await handler(self, exc, tries, mask, log)
             else:
-                if response := await handler(self, response, tries, mask):
+                if response := await handler(self, response, tries, mask, log):
                     return response
 
             tries += 1
@@ -1275,7 +1307,7 @@ class Client(metaclass=ClientMetaclass):
                 pass
         self.token_getting = False
 
-    async def client_token_apply(self, client):
+    def client_token_apply(self, client):
         """
         Actually provision self.client with self.token.
 
@@ -1317,9 +1349,19 @@ class Client(metaclass=ClientMetaclass):
         """
         raise NotImplementedError()
 
-    async def request(self, method, url, handler=None, quiet=False,
-                      accepts=None, refuses=None, tries=None, backoff=None,
-                      retries=True, semaphore=None, mask=None, **kwargs):
+    async def request(
+        # base arguments
+        self, method, url,
+        *,
+        # cli2 arguments
+        handler=None, quiet=False, accepts=None, refuses=None, tries=None,
+        backoff=None, retries=True, semaphore=None, mask=None,
+        # httpx arguments
+        content=None, data=None, files=None, json=None, params=None,
+        headers=None, cookies=None, auth=httpx.USE_CLIENT_DEFAULT,
+        follow_redirects=httpx.USE_CLIENT_DEFAULT,
+        timeout=httpx.USE_CLIENT_DEFAULT, extensions=None,
+    ):
         """
         Request method
 
@@ -1388,46 +1430,71 @@ class Client(metaclass=ClientMetaclass):
             else:
                 handler = self.handler
 
-        log = self.logger.bind(method=method, url=url)
-        if not quiet or self.debug:
-            log.debug('request', **self.kwargs_log_data(kwargs, mask, quiet))
+        request = self.client.build_request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
+        )
 
-        response = await self.request_safe(
-            method,
-            url,
+        log = self.logger.bind(method=method, url=str(request.url))
+        if not quiet or self.debug:
+            key, value = self.request_log_data(request, mask, quiet)
+            kwargs = dict()
+            if value:
+                kwargs[key] = value
+            log.debug('request', **kwargs)
+
+        response = await self.send(
+            request,
             handler=handler,
             retries=retries,
             semaphore=semaphore,
             mask=mask,
-            **kwargs,
+            log=log,
+            auth=auth,
+            follow_redirects=follow_redirects,
         )
 
         _log = dict(status_code=response.status_code)
         if not quiet or self.debug:
-            self.response_log_data(response, mask, _log)
+            key, value = self.response_log_data(response, mask)
+            if value:
+                _log[key] = value
 
         log.info('response', **_log)
 
         return response
 
-    def response_log_data(self, response, mask, log=None):
+    def response_log_data(self, response, mask):
         try:
-            data = self.mask_data(response.json(), mask)
-            key = 'json'
+            data = response.json()
         except json.JSONDecodeError:
-            data = self.mask_content(response.content, mask)
-            key = 'content'
-
-        if log:
-            log[key] = data
-        return data
+            if response.content:
+                return 'content', self.mask_content(response.content, mask)
+        else:
+            if data:
+                return 'json', self.mask_data(data, mask)
+        return None, None
 
     def request_log_data(self, request, mask, quiet=False):
         content = request.content.decode()
+        if not content:
+            return None, None
+
         try:
-            return self.mask_data(json.loads(content), mask)
+            data = json.loads(content)
         except json.JSONDecodeError:
             pass
+        else:
+            return 'json', self.mask_data(data, mask)
 
         parsed = parse_qs(content)
         if parsed:
@@ -1435,18 +1502,9 @@ class Client(metaclass=ClientMetaclass):
                 key: value[0] if len(value) == 1 else value
                 for key, value in parsed.items()
             }
-            return self.mask_data(data, mask)
-
-        return self.mask_content(content, mask)
-
-    def kwargs_log_data(self, kwargs, mask, quiet=False):
-        _log = kwargs.copy()
-        if 'content' in kwargs:
-            _log['content'] = self.mask_content(kwargs['content'], mask)
-        for key in ('json', 'data'):
-            if key in kwargs:
-                _log[key] = self.mask_data(kwargs[key], mask)
-        return _log
+            return 'data', self.mask_data(data, mask)
+
+        return 'content', self.mask_content(content, mask)
 
     def mask_content(self, content, mask=None):
         """

{cli2-3.3.25 → cli2-3.3.29}/cli2/test_client.py

@@ -15,9 +15,9 @@ class HandlerSentinel(cli2.Handler):
         super().__init__(*args, **kwargs)
         self.calls = []
 
-    async def __call__(self, client, response, tries, mask):
+    async def __call__(self, client, response, tries, mask, log):
         self.calls.append((client, response.status_code, tries))
-        return await super().__call__(client, response, tries, mask)
+        return await super().__call__(client, response, tries, mask, log)
 
 
 @pytest.fixture
@@ -154,7 +154,7 @@ async def test_error_remote(httpx_mock):
         global raised
         raised = True
         raise httpx.RemoteProtocolError('foo')
-    client.client.request = raises
+    client.client.send = raises
     old_client = client.client
     response = await client.get('http://lol')
     assert client.client is not old_client
@@ -186,12 +186,14 @@ async def test_factory(httpx_mock, client_class):
 async def test_client_handler(httpx_mock, client_class):
     class Client(client_class):
         def client_factory(self):
-            return mock.Mock()
+            client = super().client_factory()
+            client.send = mock.Mock()
+            return client
 
     client = Client(handler=HandlerSentinel())
 
     # test response retry
-    client.client.request.side_effect = [
+    client.client.send.side_effect = [
         _response(status_code=500),
         _response(status_code=200),
     ]
@@ -203,7 +205,7 @@ async def test_client_handler(httpx_mock, client_class):
     ]
 
     # test TransportError retry
-    client.client.request.side_effect = [
+    client.client.send.side_effect = [
         httpx.TransportError("foo"),
         _response(status_code=200),
     ]
@@ -216,23 +218,30 @@ async def test_client_handler(httpx_mock, client_class):
 
 @pytest.mark.asyncio
 async def test_handler(client_class):
+    log = mock.Mock()
     client = client_class()
     client.client_reset = mock.AsyncMock()
     client.token_reset = mock.AsyncMock()
     handler = cli2.Handler(accepts=[201], refuses=[218], retokens=[418])
 
     response = httpx.Response(status_code=201)
-    result = await handler(client, response, 0, [])
+    result = await handler(client, response, 0, [], log)
     assert result == response
 
     response = httpx.Response(status_code=200)
-    result = await handler(client, response, 0, [])
+    result = await handler(client, response, 0, [], log)
+    log.info.assert_called_once_with(
+        'retry', status_code=200, tries=0, sleep=.0
+    )
     assert not result
 
     response = httpx.Response(status_code=200, content='[2]')
     response.request = httpx.Request('POST', '/', json=[1])
     with pytest.raises(cli2.RetriesExceededError) as exc:
-        await handler(client, response, handler.tries + 1, [])
+        await handler(client, response, handler.tries + 1, [], log)
+    log.info.assert_called_once_with(
+        'retry', status_code=200, tries=0, sleep=.0
+    )
 
     msg = 'Unacceptable response <Response [200 OK]> after 31 tries\n\x1b[0m\x1b[1mPOST /\x1b[0m\n-\x1b[37m \x1b[39;49;00m1\x1b[37m\x1b[39;49;00m\n\n\x1b[1mHTTP 200\x1b[0m\n-\x1b[37m \x1b[39;49;00m2\x1b[37m\x1b[39;49;00m\n'  # noqa
     assert str(exc.value) == msg
@@ -240,7 +249,7 @@ async def test_handler(client_class):
     response = httpx.Response(status_code=200)
     response.request = httpx.Request('GET', '/')
     with pytest.raises(cli2.RetriesExceededError) as exc:
-        await handler(client, response, handler.tries + 1, [])
+        await handler(client, response, handler.tries + 1, [], log)
 
     msg = 'Unacceptable response <Response [200 OK]> after 31 tries\n\x1b[0m\x1b[1mGET /\x1b[0m\n\x1b[1mHTTP 200\x1b[0m'  # noqa
     assert str(exc.value) == msg
@@ -248,31 +257,38 @@ async def test_handler(client_class):
     response = httpx.Response(status_code=218)
     response.request = httpx.Request('POST', '/')
     with pytest.raises(cli2.RefusedResponseError):
-        await handler(client, response, 1, [])
+        await handler(client, response, 1, [], log)
 
     response = httpx.Response(status_code=418)
     response.request = httpx.Request('POST', '/')
     with pytest.raises(cli2.TokenGetError):
-        await handler(client, response, 1, [])
+        await handler(client, response, 1, [], log)
 
     assert not client.client_reset.await_count
-    result = await handler(client, httpx.TransportError('foo'), 0, [])
+    result = await handler(client, httpx.TransportError('foo'), 0, [], log)
+    log.warn.assert_called_once_with('reconnect', exception='foo')
     assert not result
     assert client.client_reset.await_count == 1
 
     with pytest.raises(httpx.TransportError) as exc:
-        await handler(client, httpx.TransportError('x'), handler.tries + 1, [])
+        await handler(
+            client, httpx.TransportError('x'), handler.tries + 1, [], log
+        )
 
     response = httpx.Response(status_code=418)
     assert not client.token_reset.await_count
-    result = await handler(client, response, 0, [])
+    log.warn.reset_mock()
+    result = await handler(client, response, 0, [], log)
+    log.warn.assert_called_once_with(
+        'retoken', status_code=418, tries=0, sleep=.0
+    )
     assert not result
     assert client.token_reset.await_count == 1
 
     handler = cli2.Handler(accepts=[], refuses=[222])
 
     response = httpx.Response(status_code=123)
-    result = await handler(client, response, 0, [])
+    result = await handler(client, response, 0, [], log)
     assert result == response
 
 
@@ -285,16 +301,14 @@ async def test_retry(httpx_mock, client_class):
             return self.return_token
 
         def client_factory(self):
-            return mock.Mock()
+            client = super().client_factory()
+            client.send = mock.Mock()
+            return client
 
-    client = Client(
-        retry_request=[500],
-        recreate_client=[400],
-        backoff=0.1,
-    )
+    client = Client()
 
     current_client = client.client
-    client.client.request.side_effect = [
+    client.client.send.side_effect = [
         _response(status_code=500),
         _response(status_code=500),
         _response(status_code=200),
@@ -348,6 +362,12 @@ async def test_pagination_initialize(httpx_mock):
     client = PaginatedClient(base_url='http://lol')
     assert await client.paginate('/').list() == [dict(a=1), dict(a=2)]
 
+    httpx_mock.add_response(url='http://lol/?page=1', json=dict(
+        total_pages=2,
+        items=[dict(a=1)],
+    ))
+    assert await client.paginate('/').first() == dict(a=1)
+
 
 @pytest.mark.asyncio
 async def test_token_get(httpx_mock):
@@ -768,7 +788,7 @@ def test_datetime_default_fmt():
 )
 async def test_mask_logs(key):
     client = Client(mask=['scrt', 'password'])
-    client.client = mock.AsyncMock()
+    client.client.send = mock.AsyncMock()
 
     client.logger = mock.Mock()
     response = httpx.Response(
@@ -777,9 +797,12 @@ async def test_mask_logs(key):
     )
     data = dict(foo='bar', password='secret')
     response.request = httpx.Request('POST', '/', **{key: data})
-    client.client.request.return_value = response
+    client.client.send.return_value = response
     await client.post('/', **{key: data})
-    client.logger.bind.assert_called_once_with(method='POST', url='/')
+    client.logger.bind.assert_called_once_with(
+        method='POST',
+        url='http://lol/',
+    )
     log = client.logger.bind.return_value
     log.debug.assert_called_once_with(
         'request',
@@ -816,7 +839,7 @@ async def test_mask_exceptions(client_class):
 @pytest.mark.asyncio
 async def test_request_mask():
     client = Client(mask=['password'])
-    client.client = mock.AsyncMock()
+    client.client.send = mock.AsyncMock()
 
     client.logger = mock.Mock()
     response = httpx.Response(
@@ -825,9 +848,12 @@ async def test_request_mask():
     )
     data = dict(foo='bar', password='secret')
     response.request = httpx.Request('POST', '/', json=data)
-    client.client.request.return_value = response
+    client.client.send.return_value = response
     await client.post('/', json=data, mask=['scrt'])
-    client.logger.bind.assert_called_once_with(method='POST', url='/')
+    client.logger.bind.assert_called_once_with(
+        method='POST',
+        url='http://lol/'
+    )
     log = client.logger.bind.return_value
     log.debug.assert_called_once_with(
         'request',
@@ -843,13 +869,16 @@ async def test_request_mask():
 @pytest.mark.asyncio
 async def test_log_content():
     client = Client()
-    client.client = mock.AsyncMock()
+    client.client.send = mock.AsyncMock()
     client.logger = mock.Mock()
     response = httpx.Response(status_code=200, content='lol:]bar')
     response.request = httpx.Request('POST', '/')
-    client.client.request.return_value = response
+    client.client.send.return_value = response
     await client.post('/', content='lol:]foo')
-    client.logger.bind.assert_called_once_with(method='POST', url='/')
+    client.logger.bind.assert_called_once_with(
+        method='POST',
+        url='http://lol/'
+    )
     log = client.logger.bind.return_value
     log.debug.assert_called_once_with('request', content='lol:]foo')
     log.info.assert_called_once_with(
@@ -860,14 +889,17 @@ async def test_log_content():
 @pytest.mark.asyncio
 async def test_log_quiet():
     client = Client()
-    client.client = mock.AsyncMock()
+    client.client.send = mock.AsyncMock()
     client.logger = mock.Mock()
     response = httpx.Response(status_code=200, content='[1]')
     response.request = httpx.Request('GET', '/')
-    client.client.request.return_value = response
+    client.client.send.return_value = response
     await client.get('/', json=[1], quiet=True)
     log = client.logger.bind.return_value
-    client.logger.bind.assert_called_once_with(method='GET', url='/')
+    client.logger.bind.assert_called_once_with(
+        method='GET',
+        url='http://lol/',
+    )
     log = client.logger.bind.return_value
     assert not log.debug.call_args_list
     log.info.assert_called_once_with('response', status_code=200)
@@ -933,7 +965,7 @@ def test_id_value():
 @pytest.mark.asyncio
 async def test_debug():
     client = Client(mask=['scrt', 'password'], debug=True)
-    client.client = mock.AsyncMock()
+    client.client.send = mock.AsyncMock()
 
     client.logger = mock.Mock()
     response = httpx.Response(
@@ -942,9 +974,12 @@ async def test_debug():
     )
     data = dict(foo='bar', password='secret')
     response.request = httpx.Request('POST', '/', json=data)
-    client.client.request.return_value = response
+    client.client.send.return_value = response
     await client.post('/', json=data, quiet=True)
-    client.logger.bind.assert_called_once_with(method='POST', url='/')
+    client.logger.bind.assert_called_once_with(
+        method='POST',
+        url='http://lol/',
+    )
     log = client.logger.bind.return_value
     log.debug.assert_called_once_with(
         'request',

{cli2-3.3.25 → cli2-3.3.29/cli2.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cli2
-Version: 3.3.25
+Version: 3.3.29
 Summary: image:: https://yourlabs.io/oss/cli2/badges/master/pipeline.svg
 Home-page: https://yourlabs.io/oss/cli2
 Author: James Pic

{cli2-3.3.25 → cli2-3.3.29}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup
 
 setup(
     name='cli2',
-    version='3.3.25',
+    version='3.3.29',
     setup_requires='setupmeta',
     install_requires=[
         'docstring_parser',