flake8.cfg consistent with cookiecutter template 🍪

Author: soustruh

flake8.cfg

@@ -1,21 +1,9 @@
 [flake8]
 exclude =
-    .git,
     __pycache__,
-    tests,
-    mapping.py,
-    __init__.py
-max-line-length = 119
-
-# F812: list comprehension redefines ...
-# H101: Use TODO(NAME)
-# H202: assertRaises Exception too broad
-# H233: Python 3.x incompatible use of print operator
-# H301: one import per line
-# H306: imports not in alphabetical order (time, os)
-# H401: docstring should not start with a space
-# H403: multi line docstrings should end on a new line
-# H404: multi line docstring should start without a leading new line
-# H405: multi line docstring summary not separated with an empty line
-# H501: Do not use self.__dict__ for string formatting
-ignore = F812,H101,H202,H233,H301,H306,H401,H403,H404,H405,H501
+    .git,
+    .venv,
+    venv,
+    docs
+ignore = E203,W503
+max-line-length = 120

tests/test_async.py

@@ -1,6 +1,8 @@
 import unittest
 from unittest.mock import patch
+
 import httpx
+
 from keboola.http_client import AsyncHttpClient
 
 
@@ -15,7 +17,7 @@ async def test_get(self):
 
         client = AsyncHttpClient(self.base_url, retries=self.retries)
 
-        with patch.object(httpx.AsyncClient, 'request', return_value=mock_response) as mock_request:
+        with patch.object(httpx.AsyncClient, "request", return_value=mock_response) as mock_request:
             response = await client.get("/endpoint")
             self.assertEqual(response, expected_response)
             mock_request.assert_called_once_with("GET", url="https://api.example.com/endpoint")
@@ -27,11 +29,12 @@ async def test_post(self):
 
         client = AsyncHttpClient(self.base_url, retries=self.retries)
 
-        with patch.object(httpx.AsyncClient, 'request', return_value=mock_response) as mock_request:
+        with patch.object(httpx.AsyncClient, "request", return_value=mock_response) as mock_request:
             response = await client.post("/endpoint", json={"data": "example"})
             self.assertEqual(response, expected_response)
-            mock_request.assert_called_once_with("POST", url="https://api.example.com/endpoint",
-                                                 json={"data": "example"})
+            mock_request.assert_called_once_with(
+                "POST", url="https://api.example.com/endpoint", json={"data": "example"}
+            )
 
     async def test_handle_success_response(self):
         expected_response = {"message": "Success"}
@@ -40,7 +43,7 @@ async def test_handle_success_response(self):
 
         client = AsyncHttpClient(self.base_url, retries=self.retries)
 
-        with patch.object(httpx.AsyncClient, 'request', return_value=mock_response) as mock_request:
+        with patch.object(httpx.AsyncClient, "request", return_value=mock_response) as mock_request:
             response = await client.get("/endpoint")
             self.assertEqual(response, expected_response)
             mock_request.assert_called_once_with("GET", url="https://api.example.com/endpoint")
@@ -51,7 +54,7 @@ async def test_handle_client_error_response(self):
 
         client = AsyncHttpClient(self.base_url, retries=self.retries, retry_status_codes=[404])
 
-        with patch.object(httpx.AsyncClient, 'request', return_value=mock_response) as mock_request:
+        with patch.object(httpx.AsyncClient, "request", return_value=mock_response) as mock_request:
             with self.assertRaises(httpx.HTTPStatusError):
                 await client.get("/endpoint")
 
@@ -65,15 +68,15 @@ async def test_handle_server_error_response(self):
 
         client = AsyncHttpClient(self.base_url, retries=self.retries, retry_status_codes=[500])
 
-        with patch.object(httpx.AsyncClient, 'request', return_value=mock_response) as mock_request:
+        with patch.object(httpx.AsyncClient, "request", return_value=mock_response) as mock_request:
             with self.assertRaises(httpx.HTTPStatusError):
                 await client.get("/endpoint")
 
             assert mock_request.call_count == self.retries + 1
 
             mock_request.assert_called_with("GET", url="https://api.example.com/endpoint")
 
-    @patch.object(httpx.AsyncClient, 'request')
+    @patch.object(httpx.AsyncClient, "request")
     async def test_post_raw_default_pars_with_none_custom_pars_passes(self, mock_request):
         url = f"{self.base_url}/endpoint"
         test_def_par = {"default_par": "test"}
@@ -84,7 +87,7 @@ async def test_post_raw_default_pars_with_none_custom_pars_passes(self, mock_req
 
         mock_request.assert_called_once_with("POST", url=url, params=test_def_par)
 
-    @patch.object(httpx.AsyncClient, 'request')
+    @patch.object(httpx.AsyncClient, "request")
     async def test_post_default_pars_with_none_custom_pars_passes(self, mock_request):
         url = f"{self.base_url}/endpoint"
         test_def_par = {"default_par": "test"}
@@ -95,7 +98,7 @@ async def test_post_default_pars_with_none_custom_pars_passes(self, mock_request
 
         mock_request.assert_called_once_with("POST", url=url, params=test_def_par)
 
-    @patch.object(httpx.AsyncClient, 'request')
+    @patch.object(httpx.AsyncClient, "request")
     async def test_post_raw_default_pars_with_custom_pars_passes(self, mock_request):
         url = f"{self.base_url}/endpoint"
         test_def_par = {"default_par": "test"}
@@ -108,7 +111,7 @@ async def test_post_raw_default_pars_with_custom_pars_passes(self, mock_request)
         test_cust_def_par = {**test_def_par, **cust_par}
         mock_request.assert_called_once_with("POST", url=url, params=test_cust_def_par)
 
-    @patch.object(httpx.AsyncClient, 'request')
+    @patch.object(httpx.AsyncClient, "request")
     async def test_post_default_pars_with_custom_pars_passes(self, mock_request):
         url = f"{self.base_url}/endpoint"
         test_def_par = {"default_par": "test"}
@@ -121,7 +124,7 @@ async def test_post_default_pars_with_custom_pars_passes(self, mock_request):
         test_cust_def_par = {**test_def_par, **cust_par}
         mock_request.assert_called_once_with("POST", url=url, params=test_cust_def_par)
 
-    @patch.object(httpx.AsyncClient, 'request')
+    @patch.object(httpx.AsyncClient, "request")
     async def test_post_raw_default_pars_with_custom_pars_to_None_passes(self, mock_request):
         url = f"{self.base_url}/endpoint"
         test_def_par = {"default_par": "test"}
@@ -136,7 +139,7 @@ async def test_post_raw_default_pars_with_custom_pars_to_None_passes(self, mock_
         test_cust_def_par = {**test_def_par, **_cust_par_transformed}
         mock_request.assert_called_once_with("POST", url=url, params=test_cust_def_par)
 
-    @patch.object(httpx.AsyncClient, 'request')
+    @patch.object(httpx.AsyncClient, "request")
     async def test_post_default_pars_with_custom_pars_to_None_passes(self, mock_request):
         url = f"{self.base_url}/endpoint"
         test_def_par = {"default_par": "test"}
@@ -151,146 +154,162 @@ async def test_post_default_pars_with_custom_pars_to_None_passes(self, mock_requ
         test_cust_def_par = {**test_def_par, **_cust_par_transformed}
         mock_request.assert_called_once_with("POST", url=url, params=test_cust_def_par)
 
-    @patch.object(httpx.AsyncClient, 'request')
+    @patch.object(httpx.AsyncClient, "request")
     async def test_all_methods_requests_raw_with_custom_pars_passes(self, mock_request):
         client = AsyncHttpClient(self.base_url)
 
         cust_par = {"custom_par": "custom_par_value"}
 
         for m in client.ALLOWED_METHODS:
             await client._request(m, ignore_auth=False, params=cust_par)
-            mock_request.assert_called_with(m, url=self.base_url+"/", params=cust_par)
+            mock_request.assert_called_with(m, url=self.base_url + "/", params=cust_par)
 
-    @patch.object(httpx.AsyncClient, 'request')
+    @patch.object(httpx.AsyncClient, "request")
     async def test_all_methods_skip_auth(self, mock_request):
         client = AsyncHttpClient(self.base_url, auth=("my_user", "password123"))
 
-        for m in ['GET', 'POST', 'PATCH', 'UPDATE', 'PUT', 'DELETE']:
+        for m in ["GET", "POST", "PATCH", "UPDATE", "PUT", "DELETE"]:
             await client._request(m, ignore_auth=True)
-            mock_request.assert_called_with(m, url=self.base_url+"/")
+            mock_request.assert_called_with(m, url=self.base_url + "/")
 
-    @patch.object(httpx.AsyncClient, 'request')
+    @patch.object(httpx.AsyncClient, "request")
     async def test_request_skip_auth_header(self, mock_request):
         def_header = {"def_header": "test"}
-        client = AsyncHttpClient('http://example.com', default_headers=def_header,
-                               auth_header={"Authorization": "test"})
+        client = AsyncHttpClient(
+            "http://example.com", default_headers=def_header, auth_header={"Authorization": "test"}
+        )
 
-        await client._request('POST', 'abc', ignore_auth=True)
-        mock_request.assert_called_with('POST', url="http://example.com/abc", headers=def_header)
+        await client._request("POST", "abc", ignore_auth=True)
+        mock_request.assert_called_with("POST", url="http://example.com/abc", headers=def_header)
 
-    @patch.object(httpx.AsyncClient, 'request')
+    @patch.object(httpx.AsyncClient, "request")
     async def test_request_auth(self, mock_request):
         def_header = {"def_header": "test"}
         auth = ("my_user", "password123")
         client = AsyncHttpClient(self.base_url, auth=auth, default_headers=def_header)
 
-        await client._request('POST', 'abc')
-        mock_request.assert_called_with('POST', url=self.base_url+"/abc", headers=def_header,
-                                        auth=auth)
+        await client._request("POST", "abc")
+        mock_request.assert_called_with("POST", url=self.base_url + "/abc", headers=def_header, auth=auth)
 
-    @patch.object(httpx.AsyncClient, 'request')
+    @patch.object(httpx.AsyncClient, "request")
     async def test_all_methods(self, mock_request):
-        client = AsyncHttpClient(self.base_url, default_headers={'header1': 'headerval'},
-                                auth_header={'api_token': 'abdc1234'})
+        client = AsyncHttpClient(
+            self.base_url, default_headers={"header1": "headerval"}, auth_header={"api_token": "abdc1234"}
+        )
 
-        target_url = f'{self.base_url}/abc'
+        target_url = f"{self.base_url}/abc"
 
         for m in client.ALLOWED_METHODS:
-            await client._request(m, 'abc', params={'exclude': 'componentDetails'}, headers={'abc': '123'},
-                                  data={'attr1': 'val1'})
-            mock_request.assert_called_with(m, url=target_url,
-                                            params={'exclude': 'componentDetails'},
-                                            headers={'api_token': 'abdc1234', 'header1': 'headerval', 'abc': '123'},
-                                            data={'attr1': 'val1'})
-
-    @patch.object(httpx.AsyncClient, 'request')
+            await client._request(
+                m, "abc", params={"exclude": "componentDetails"}, headers={"abc": "123"}, data={"attr1": "val1"}
+            )
+            mock_request.assert_called_with(
+                m,
+                url=target_url,
+                params={"exclude": "componentDetails"},
+                headers={"api_token": "abdc1234", "header1": "headerval", "abc": "123"},
+                data={"attr1": "val1"},
+            )
+
+    @patch.object(httpx.AsyncClient, "request")
     async def test_all_methods_requests_raw_with_is_absolute_path_true(self, mock_request):
         def_header = {"def_header": "test"}
         client = AsyncHttpClient(self.base_url, default_headers=def_header)
 
         for m in client.ALLOWED_METHODS:
-            await client._request(m, 'http://example2.com/v1/', is_absolute_path=True)
-            mock_request.assert_called_with(m, url='http://example2.com/v1/', headers=def_header)
+            await client._request(m, "http://example2.com/v1/", is_absolute_path=True)
+            mock_request.assert_called_with(m, url="http://example2.com/v1/", headers=def_header)
 
-    @patch.object(httpx.AsyncClient, 'request')
+    @patch.object(httpx.AsyncClient, "request")
     async def test_all_methods_requests_raw_with_is_absolute_path_false(self, mock_request):
         def_header = {"def_header": "test"}
         client = AsyncHttpClient(self.base_url, default_headers=def_header)
 
         for m in client.ALLOWED_METHODS:
-            await client._request(m, 'cars')
-            mock_request.assert_called_with(m, url=self.base_url+"/cars", headers=def_header)
+            await client._request(m, "cars")
+            mock_request.assert_called_with(m, url=self.base_url + "/cars", headers=def_header)
 
-    @patch.object(httpx.AsyncClient, 'request')
+    @patch.object(httpx.AsyncClient, "request")
     async def test_all_methods_kwargs(self, mock_request):
         client = AsyncHttpClient(self.base_url)
 
         for m in client.ALLOWED_METHODS:
-            await client._request(m, 'cars', data={'data': '123'}, cert='/path/to/cert', files={'a': '/path/to/file'},
-                                            params={'par1': 'val1'})
-
-            mock_request.assert_called_with(m, url=self.base_url+"/cars", data={'data': '123'},
-                                            cert='/path/to/cert', files={'a': '/path/to/file'},
-                                            params={'par1': 'val1'})
+            await client._request(
+                m,
+                "cars",
+                data={"data": "123"},
+                cert="/path/to/cert",
+                files={"a": "/path/to/file"},
+                params={"par1": "val1"},
+            )
+
+            mock_request.assert_called_with(
+                m,
+                url=self.base_url + "/cars",
+                data={"data": "123"},
+                cert="/path/to/cert",
+                files={"a": "/path/to/file"},
+                params={"par1": "val1"},
+            )
 
     async def test_build_url_rel_path(self):
-        url = 'https://example.com/'
+        url = "https://example.com/"
         cl = AsyncHttpClient(url)
-        expected_url = 'https://example.com/storage'
-        actual_url = await cl._build_url('storage')
+        expected_url = "https://example.com/storage"
+        actual_url = await cl._build_url("storage")
         self.assertEqual(expected_url, actual_url)
 
     async def test_build_url_abs_path(self):
-        url = 'https://example.com/'
+        url = "https://example.com/"
         cl = AsyncHttpClient(url)
-        expected_url = 'https://example2.com/storage'
-        actual_url = await cl._build_url('https://example2.com/storage', True)
+        expected_url = "https://example2.com/storage"
+        actual_url = await cl._build_url("https://example2.com/storage", True)
         self.assertEqual(expected_url, actual_url)
 
     async def test_build_url_empty_endpoint_path_leads_to_base_url(self):
-        url = 'https://example.com/'
+        url = "https://example.com/"
         cl = AsyncHttpClient(url)
         expected_url = url
 
         actual_url = await cl._build_url()
         self.assertEqual(expected_url, actual_url)
 
-        actual_url = await cl._build_url('')
+        actual_url = await cl._build_url("")
         self.assertEqual(expected_url, actual_url)
 
         actual_url = await cl._build_url(None)
         self.assertEqual(expected_url, actual_url)
 
-        actual_url = await cl._build_url('', is_absolute_path=True)
+        actual_url = await cl._build_url("", is_absolute_path=True)
         self.assertEqual(expected_url, actual_url)
 
         actual_url = await cl._build_url(None, is_absolute_path=True)
         self.assertEqual(expected_url, actual_url)
 
     async def test_build_url_base_url_appends_slash(self):
-        url = 'https://example.com'
+        url = "https://example.com"
         cl = AsyncHttpClient(url)
-        expected_base_url = 'https://example.com/'
+        expected_base_url = "https://example.com/"
 
         self.assertEqual(expected_base_url, cl.base_url)
 
     async def test_update_auth_header_None(self):
         existing_header = None
-        new_header = {'api_token': 'token_value'}
+        new_header = {"api_token": "token_value"}
 
-        cl = AsyncHttpClient('https://example.com', auth_header=existing_header)
+        cl = AsyncHttpClient("https://example.com", auth_header=existing_header)
         await cl.update_auth_header(new_header, overwrite=False)
         self.assertDictEqual(cl._auth_header, new_header)
 
-        new_header_2 = {'password': '123'}
+        new_header_2 = {"password": "123"}
         await cl.update_auth_header(new_header_2, overwrite=True)
         self.assertDictEqual(cl._auth_header, new_header_2)
 
     async def test_update_existing_auth_header(self):
-        existing_header = {'authorization': 'value'}
-        new_header = {'api_token': 'token_value'}
+        existing_header = {"authorization": "value"}
+        new_header = {"api_token": "token_value"}
 
-        cl = AsyncHttpClient('https://example.com', auth_header=existing_header)
+        cl = AsyncHttpClient("https://example.com", auth_header=existing_header)
         await cl.update_auth_header(new_header, overwrite=False)
         self.assertDictEqual(cl._auth_header, {**existing_header, **new_header})
 
@@ -300,11 +319,12 @@ async def test_detailed_exception(self):
 
         client = AsyncHttpClient(self.base_url)
 
-        with patch.object(httpx.AsyncClient, 'request', return_value=mock_response) as mock_request:
+        with patch.object(httpx.AsyncClient, "request", return_value=mock_response) as _:
             with self.assertRaises(httpx.HTTPStatusError) as e:
                 await client.get("/endpoint")
 
             assert "Client error '404 Not Found' for url 'https://api.example.com/endpoint'" in str(e.exception)
 
+
 if __name__ == "__main__":
     unittest.main()