feat(repository): add method in BaseMonoManager

Author: IhorSotnyk

monobank_api_client/async_mono/manager.py

@@ -24,10 +24,10 @@ async def async_request(
             code = response.status
             response.raise_for_status()
             detail = await response.json()
-            payload = {"code": code, "detail": detail}
+            payload = self.mono_response(code, detail)
             return payload
         except aiohttp.ClientResponseError as exc:
-            error_response = {"code": code, "detail": str(exc.message)}
+            error_response = self.mono_response(code, str(exc.message))
             return error_response
         except Exception as exc:
             exception = {"detail": str(exc)}
@@ -42,15 +42,14 @@ async def get_currencies(self) -> Dict:
             exception = {"datail": str(exc)}
             return exception
 
-    async def get_currency(self, ccy_pair: str) -> Dict:
+    async def get_currency(self, ccy: str) -> Dict:
         try:
-            pair = self.mono_currencies.get(ccy_pair)
+            pair = self.mono_currencies.get(ccy)
             if pair is not None:
                 currencies = await self.get_currencies()
-                response = self.currency(ccy_pair, pair, currencies)
+                response = self.currency(ccy, pair, currencies)
             else:
-                list_ccy = [key for key in self.mono_currencies.keys()]
-                response = self.currency_exception(list_ccy)
+                response = self.currency_exception()
             return response
         except Exception as exc:
             exception = {"detail": str(exc)}
@@ -69,14 +68,14 @@ async def get_client_info(self) -> Dict:
 
     async def get_balance(self) -> Dict:
         try:
-            info = await self.get_client_info()
-            code = info.get("code")
-            data = info.get("detail")
+            payload = await self.get_client_info()
+            code = payload.get("code")
+            data = payload.get("detail")
             balance = {"balance": data["accounts"][0]["balance"] / 100}
-            response = {"code": code, "detail": balance}
+            response = self.mono_response(code, balance)
             return response
         except Exception:
-            return info
+            return payload
 
     async def get_statement(self, period: int) -> Dict:
         try:

monobank_api_client/fastapi_mono/router.py

@@ -15,7 +15,8 @@ async def add_monobank(
     schema: MonoSchema, session: AsyncSession = Depends(async_session)
 ) -> Dict:
     try:
-        return await crud.create_mono(schema, session)
+        response = await crud.create_mono(schema, session)
+        return response
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception
@@ -28,7 +29,8 @@ async def change_monobank(
     session: AsyncSession = Depends(async_session),
 ) -> Dict:
     try:
-        return await crud.update_mono(user, schema, session)
+        response = await crud.update_mono(user, schema, session)
+        return response
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception
@@ -39,7 +41,8 @@ async def delete_monobank(
     user: str, session: AsyncSession = Depends(async_session)
 ) -> Dict:
     try:
-        return await crud.delete_mono(user, session)
+        response = await crud.delete_mono(user, session)
+        return response
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception
@@ -49,7 +52,8 @@ async def delete_monobank(
 async def currencies() -> Dict:
     try:
         mng = AsyncMonoManager()
-        return await mng.get_currencies()
+        response = await mng.get_currencies()
+        return response
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception
@@ -59,7 +63,8 @@ async def currencies() -> Dict:
 async def currency(ccy_pair: str) -> Dict:
     try:
         mng = AsyncMonoManager()
-        return await mng.get_currency(ccy_pair)
+        response = await mng.get_currency(ccy_pair)
+        return response
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception
@@ -74,8 +79,10 @@ async def client_info(
         payload = await crud.read_mono(user_id, session)
         if payload is not None:
             mng.token = payload[0].mono_token
-            return await mng.get_client_info()
-        return mng.does_not_exsists_exception()
+            response = await mng.get_client_info()
+        else:
+            response = mng.does_not_exsists_exception()
+        return response
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception
@@ -88,8 +95,10 @@ async def balance(user_id: str, session: AsyncSession = Depends(async_session))
         payload = await crud.read_mono(user_id, session)
         if payload is not None:
             mng.token = payload[0].mono_token
-            return await mng.get_balance()
-        return mng.does_not_exsists_exception()
+            response = await mng.get_balance()
+        else:
+            response = mng.does_not_exsists_exception()
+        return response
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception
@@ -104,8 +113,10 @@ async def statement(
         payload = await crud.read_mono(user_id, session)
         if payload is not None:
             mng.token = payload[0].mono_token
-            return await mng.get_statement(period)
-        return mng.does_not_exsists_exception()
+            response = await mng.get_statement(period)
+        else:
+            response = mng.does_not_exsists_exception()
+        return response
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception
@@ -120,8 +131,10 @@ async def webhook(
         payload = await crud.read_mono(user_id, session)
         if payload is not None:
             mng.token = payload[0].mono_token
-            return await mng.create_webhook(webhook)
-        return mng.does_not_exsists_exception()
+            response = await mng.create_webhook(webhook)
+        else:
+            response = mng.does_not_exsists_exception()
+        return response
     except Exception as exc:
         exception = {"detail": str(exc)}
         return exception

monobank_api_client/mono_config/manager.py

@@ -1,4 +1,4 @@
-from typing import Dict, List
+from typing import Dict, Any
 from datetime import datetime
 from .config import (
     MONOBANK_CURRENCIES_URI,
@@ -218,94 +218,103 @@ def date(period: int) -> Dict:
             exception = {"detail": str(exc)}
             return exception
 
-    def currency(self, ccy_pair: str, pair: Dict, currencies: Dict) -> Dict:
+    def mono_response(self, code: int, detail: Any, info=None) -> Dict:
+        try:
+            if info is not None:
+                response = {"code": code, "detail": detail, "info": info}
+            else:
+                response = {"code": code, "detail": detail}
+            return response
+        except Exception as exc:
+            exception = {"detail": str(exc)}
+            return exception
+
+    def currency(self, ccy: str, pair: Dict, currencies: Dict) -> Dict:
         try:
             code_a = self.mono_currency_code_a
             code_b = self.mono_currency_code_b
             code = currencies.get("code")
             payload = currencies.get("detail")
-            for ccy in payload:
-                if ccy.get(code_a) == pair.get(code_a) and ccy.get(code_b) == pair.get(
+            for _ in payload:
+                if _.get(code_a) == pair.get(code_a) and _.get(code_b) == pair.get(
                     code_b
                 ):
-                    cross = ccy.get("rateCross")
+                    cross = _.get("rateCross")
                     if cross is not None:
-                        currency = {ccy_pair: {"Cross": cross}}
+                        currency = {ccy: {"Cross": cross}}
                     else:
-                        buy = ccy.get("rateBuy")
-                        sale = ccy.get("rateSell")
-                        currency = {ccy_pair: {"Buy": buy, "Sale": sale}}
-                    response = {"code": code, "detail": currency}
+                        buy = _.get("rateBuy")
+                        sale = _.get("rateSell")
+                        currency = {ccy: {"Buy": buy, "Sale": sale}}
+                    response = self.mono_response(code, currency)
             return response
         except AttributeError:
-            error_response = {"code": code, "detail": payload}
+            error_response = self.mono_response(code, payload)
             return error_response
         except Exception as exc:
             exception = {"detail": str(exc)}
             return exception
 
     def create_success(self) -> Dict:
         try:
-            response = {
-                "code": self.mono_create_success_code,
-                "detail": self.mono_create_success_detail,
-            }
+            response = self.mono_response(
+                self.mono_create_success_code, self.mono_create_success_detail
+            )
             return response
         except Exception as exc:
             exception = {"detail": str(exc)}
             return exception
 
     def update_success(self) -> Dict:
         try:
-            response = {
-                "code": self.mono_update_success_code,
-                "detail": self.mono_update_success_detail,
-            }
+            response = self.mono_response(
+                self.mono_update_success_code, self.mono_update_success_detail
+            )
             return response
         except Exception as exc:
             exception = {"detail": str(exc)}
             return exception
 
     def delete_success(self) -> Dict:
         try:
-            response = {
-                "code": self.mono_delete_success_code,
-                "detail": self.mono_delete_success_detail,
-            }
+            response = self.mono_response(
+                self.mono_delete_success_code, self.mono_delete_success_detail
+            )
             return response
         except Exception as exc:
             exception = {"detail": str(exc)}
             return exception
 
-    def currency_exception(self, list_ccy: List) -> Dict:
+    def currency_exception(self) -> Dict:
         try:
-            response = {
-                "code": self.mono_currency_exception_code,
-                "detail": self.mono_currency_exception_detail,
-                "list of acceptable currency pairs": list_ccy,
-            }
+            list_ccy = [key for key in self.mono_currencies.keys()]
+            currencies_pairs = {"currencies pairs": list_ccy}
+            response = self.mono_response(
+                self.mono_currency_exception_code,
+                self.mono_currency_exception_detail,
+                currencies_pairs,
+            )
             return response
         except Exception as exc:
             exception = {"detail": str(exc)}
             return exception
 
     def exists_exception(self) -> Dict:
         try:
-            response = {
-                "code": self.mono_exsists_exception_code,
-                "detail": self.mono_exsists_exception_detail,
-            }
+            response = self.mono_response(
+                self.mono_exsists_exception_code, self.mono_exsists_exception_detail
+            )
             return response
         except Exception as exc:
             exception = {"detail": str(exc)}
             return exception
 
     def does_not_exsists_exception(self) -> Dict:
         try:
-            response = {
-                "code": self.mono_does_not_exsists_exception_code,
-                "detail": self.mono_does_not_exsists_exception_detail,
-            }
+            response = self.mono_response(
+                self.mono_does_not_exsists_exception_code,
+                self.mono_does_not_exsists_exception_detail,
+            )
             return response
         except Exception as exc:
             exception = {"detail": str(exc)}

monobank_api_client/sync_mono/manager.py

@@ -23,10 +23,11 @@ def sync_request(
         try:
             code = response.status_code
             response.raise_for_status()
-            payload = {"code": code, "detail": response.json()}
+            detail = response.json()
+            payload = self.mono_response(code, detail)
             return payload
         except requests.exceptions.HTTPError as exc:
-            error_response = {"code": code, "detail": str(exc)}
+            error_response = self.mono_response(code, str(exc))
             return error_response
         except Exception as exc:
             exception = {"detail": str(exc)}
@@ -41,15 +42,14 @@ def get_currencies(self) -> Dict:
             exception = {"detail": str(exc)}
             return exception
 
-    def get_currency(self, ccy_pair: str) -> Dict:
+    def get_currency(self, ccy: str) -> Dict:
         try:
-            pair = self.mono_currencies.get(ccy_pair)
+            pair = self.mono_currencies.get(ccy)
             if pair is not None:
                 currencies = self.get_currencies()
-                response = self.currency(ccy_pair, pair, currencies)
+                response = self.currency(ccy, pair, currencies)
             else:
-                list_ccy = [key for key in self.mono_currencies.keys()]
-                response = self.currency_exception(list_ccy)
+                response = self.currency_exception()
             return response
         except Exception as exc:
             exception = {"detail": str(exc)}
@@ -68,14 +68,14 @@ def get_client_info(self) -> Dict:
 
     def get_balance(self) -> Dict:
         try:
-            client_info = self.get_client_info()
-            code = client_info.get("code")
-            data = client_info.get("detail")
+            payload = self.get_client_info()
+            code = payload.get("code")
+            data = payload.get("detail")
             balance = {"balance": data["accounts"][0]["balance"] / 100}
-            response = {"code": code, "detail": balance}
+            response = self.mono_response(code, balance)
             return response
         except Exception:
-            return client_info
+            return payload
 
     def get_statement(self, period: int) -> Dict:
         try:

setup.py

@@ -8,7 +8,7 @@ def readme():
 
 setup(
     name="monobank_api_client",
-    version="1.2.0",
+    version="1.2.2",
     author="ihor.sotnyk",
     author_email="ihor.sotnyk@onix-systems.com",
     description="This module is designed for quick interaction with the monobank API.",