✨ publish: async/await 3

Author: FJRG2007

dymoapi/branches/private.py

@@ -1,32 +1,27 @@
-import httpx
+import requests
 from ..config import get_base_url
 from ..utils.decorators import deprecated
 from typing import Optional, Dict, Any, List
 from ..exceptions import APIError, BadRequestError
 
 @deprecated("is_valid_data_raw")
-async def is_valid_data(token, data):
-    return await is_valid_data_raw(token, data)
+def is_valid_data(token, data):
+    if not any([key in list(data.keys()) for key in ["url", "email", "phone", "domain", "creditCard", "ip", "wallet", "userAgent", "iban"]]): raise BadRequestError("You must provide at least one parameter.")
+    try:
+        response = requests.post(f"{get_base_url()}/v1/private/secure/verify", json=data, headers={"User-Agent": "DymoAPISDK/1.0.0", "X-Dymo-SDK-Env": "Python", "X-Dymo-SDK-Version" : "0.0.61", "Authorization": token})
+        response.raise_for_status()
+        return response.json()
+    except requests.RequestException as e: raise APIError(str(e))
 
-async def is_valid_data_raw(token: str, data: dict) -> dict:
+def is_valid_data_raw(token, data):
     if not any([key in list(data.keys()) for key in ["url", "email", "phone", "domain", "creditCard", "ip", "wallet", "userAgent", "iban"]]): raise BadRequestError("You must provide at least one parameter.")
     try:
-        async with httpx.AsyncClient() as client:
-            resp = await client.post(
-                f"{get_base_url()}/v1/private/secure/verify",
-                json=data,
-                headers={
-                    "User-Agent": "DymoAPISDK/1.0.0",
-                    "X-Dymo-SDK-Env": "Python",
-                    "X-Dymo-SDK-Version": "0.0.60",
-                    "Authorization": token
-                }
-            )
-        resp.raise_for_status()
-        return resp.json()
-    except httpx.RequestError as e: raise APIError(str(e))
+        response = requests.post(f"{get_base_url()}/v1/private/secure/verify", json=data, headers={"User-Agent": "DymoAPISDK/1.0.0", "X-Dymo-SDK-Env": "Python", "X-Dymo-SDK-Version" : "0.0.61", "Authorization": token})
+        response.raise_for_status()
+        return response.json()
+    except requests.RequestException as e: raise APIError(str(e))
 
-async def is_valid_email(token: Optional[str], email: str, rules: Optional[Dict[str, List[str]]] = None) -> Dict[str, Any]:
+def is_valid_email(token: Optional[str], email: str, rules: Optional[Dict[str, List[str]]] = None) -> Dict[str, Any]:
     """
     Validates the given email against the configured deny rules.
 
@@ -56,17 +51,11 @@ async def is_valid_email(token: Optional[str], email: str, rules: Optional[Dict[
     plugins = [p for p in plugins if p is not None]
 
     try:
-        async with httpx.AsyncClient() as client:
-            resp = await client.post(
-                f"{get_base_url()}/v1/private/secure/verify",
-                json={"email": email, "plugins": plugins},
-                headers={
-                    "User-Agent": "DymoAPISDK/1.0.0",
-                    "X-Dymo-SDK-Env": "Python",
-                    "X-Dymo-SDK-Version": "0.0.60",
-                    "Authorization": token
-                }
-            )
+        resp = requests.post(
+            f"{get_base_url()}/v1/private/secure/verify",
+            json={"email": email, "plugins": plugins},
+            headers={"User-Agent": "DymoAPISDK/1.0.0", "X-Dymo-SDK-Env": "Python", "X-Dymo-SDK-Version" : "0.0.61", "Authorization": token}
+        )
         resp.raise_for_status()
         data = resp.json().get("email", {})
 
@@ -99,9 +88,9 @@ async def is_valid_email(token: Optional[str], email: str, rules: Optional[Dict[
             "response": data
         }
 
-    except httpx.RequestError as e: raise APIError(f"[Dymo API] {str(e)}")
+    except requests.RequestException as e: raise APIError(f"[Dymo API] {str(e)}")
 
-async def is_valid_ip(token: Optional[str], ip: str, rules: Optional[Dict[str, List[str]]] = None) -> Dict[str, Any]:
+def is_valid_ip(token: Optional[str], ip: str, rules: Optional[Dict[str, List[str]]] = None) -> Dict[str, Any]:
     """
     Validates the given IP against the configured deny rules.
 
@@ -129,17 +118,11 @@ async def is_valid_ip(token: Optional[str], ip: str, rules: Optional[Dict[str, L
     plugins = [p for p in plugins if p is not None]
 
     try:
-        async with httpx.AsyncClient() as client:
-            resp = await client.post(
-                f"{get_base_url()}/v1/private/secure/verify",
-                json={"email": ip, "plugins": plugins},
-                headers={
-                    "User-Agent": "DymoAPISDK/1.0.0",
-                    "X-Dymo-SDK-Env": "Python",
-                    "X-Dymo-SDK-Version": "0.0.60",
-                    "Authorization": token
-                }
-            )
+        resp = requests.post(
+            f"{get_base_url()}/v1/private/secure/verify",
+            json={"email": ip, "plugins": plugins},
+            headers={"User-Agent": "DymoAPISDK/1.0.0", "X-Dymo-SDK-Env": "Python", "X-Dymo-SDK-Version" : "0.0.61", "Authorization": token}
+        )
         resp.raise_for_status()
         data = resp.json().get("ip", {})
 
@@ -170,9 +153,9 @@ async def is_valid_ip(token: Optional[str], ip: str, rules: Optional[Dict[str, L
             "response": data
         }
 
-    except httpx.RequestError as e: raise APIError(f"[Dymo API] {str(e)}")
+    except requests.RequestException as e: raise APIError(f"[Dymo API] {str(e)}")
 
-async def is_valid_phone(token: Optional[str], phone: str, rules: Optional[Dict[str, List[str]]] = None) -> Dict[str, Any]:
+def is_valid_phone(token: Optional[str], phone: str, rules: Optional[Dict[str, List[str]]] = None) -> Dict[str, Any]:
     """
     Validates the given phone against the configured deny rules.
 
@@ -199,17 +182,11 @@ async def is_valid_phone(token: Optional[str], phone: str, rules: Optional[Dict[
     plugins = [p for p in plugins if p is not None]
 
     try:
-        async with httpx.AsyncClient() as client:
-            resp = await client.post(
-                f"{get_base_url()}/v1/private/secure/verify",
-                json={"phone": phone, "plugins": plugins},
-                headers={
-                    "User-Agent": "DymoAPISDK/1.0.0",
-                    "X-Dymo-SDK-Env": "Python",
-                    "X-Dymo-SDK-Version": "0.0.60",
-                    "Authorization": token
-                }
-            )
+        resp = requests.post(
+            f"{get_base_url()}/v1/private/secure/verify",
+            json={"phone": phone, "plugins": plugins},
+            headers={"User-Agent": "DymoAPISDK/1.0.0", "X-Dymo-SDK-Env": "Python", "X-Dymo-SDK-Version" : "0.0.61", "Authorization": token}
+        )
         resp.raise_for_status()
         data = resp.json().get("phone", {})
 
@@ -239,30 +216,20 @@ async def is_valid_phone(token: Optional[str], phone: str, rules: Optional[Dict[
             "response": data
         }
 
-    except httpx.RequestError as e: raise APIError(f"[Dymo API] {str(e)}")
+    except requests.RequestException as e: raise APIError(f"[Dymo API] {str(e)}")
 
-async def send_email(token, data):
+def send_email(token, data):
     if not data.get("from"): raise BadRequestError("You must provide an email address from which the following will be sent.")
     if not data.get("to"): raise BadRequestError("You must provide an email to be sent to.")
     if not data.get("subject"): raise BadRequestError("You must provide a subject for the email to be sent.")
     if not data.get("html"): raise BadRequestError("You must provide HTML.")
     try:
-        async with httpx.AsyncClient() as client:
-            resp = await client.post(
-                f"{get_base_url()}/v1/private/sender/sendEmail",
-                json=data,
-                headers={
-                    "User-Agent": "DymoAPISDK/1.0.0",
-                    "X-Dymo-SDK-Env": "Python",
-                    "X-Dymo-SDK-Version": "0.0.60",
-                    "Authorization": token
-                }
-            )
-        resp.raise_for_status()
-        return resp.json()
-    except httpx.RequestError as e: raise APIError(str(e))
+        response = requests.post(f"{get_base_url()}/v1/private/sender/sendEmail", json=data, headers={"User-Agent": "DymoAPISDK/1.0.0", "X-Dymo-SDK-Env": "Python", "X-Dymo-SDK-Version" : "0.0.61", "Authorization": token})
+        response.raise_for_status()
+        return response.json()
+    except requests.RequestException as e: raise APIError(str(e))
 
-async def get_random(token, data):
+def get_random(token, data):
     if not data.get("from"): raise BadRequestError("You must provide an email address from which the following will be sent.")
     if not data.get("to"): raise BadRequestError("You must provide an email to be sent to.")
     if not data.get("subject"): raise BadRequestError("You must provide a subject for the email to be sent.")
@@ -273,38 +240,26 @@ async def get_random(token, data):
     if data.min < -1000000000 or data.min > 1000000000: raise BadRequestError("'min' must be an integer in the interval [-1000000000}, 1000000000].")
     if data.max < -1000000000 or data.max > 1000000000: raise BadRequestError("'max' must be an integer in the interval [-1000000000}, 1000000000].")
     try:
-        async with httpx.AsyncClient() as client:
-            resp = await client.post(
-                f"{get_base_url()}/v1/private/srng",
-                json=data,
-                headers={
-                    "User-Agent": "DymoAPISDK/1.0.0",
-                    "X-Dymo-SDK-Env": "Python",
-                    "X-Dymo-SDK-Version": "0.0.60",
-                    "Authorization": token
-                }
-            )
-        resp.raise_for_status()
-        return resp.json()
-    except httpx.RequestError as e: raise APIError(str(e))
+        response = requests.post(f"{get_base_url()}/v1/private/srng", json=data, headers={"User-Agent": "DymoAPISDK/1.0.0", "X-Dymo-SDK-Env": "Python", "X-Dymo-SDK-Version" : "0.0.61", "Authorization": token})
+        response.raise_for_status()
+        return response.json()
+    except requests.RequestException as e: raise APIError(str(e))
+
 
-async def extract_with_textly(token: str, data: dict) -> dict:
+def extract_with_textly(token: str, data: dict) -> dict:
     if not data.get("data"): raise BadRequestError("No data provided.")
     if not data.get("format"): raise BadRequestError("No format provided.")
 
     try:
-        async with httpx.AsyncClient() as client:
-            resp = await client.post(
-                f"{get_base_url()}/private/textly/extract",
-                json=data,
-                headers={
-                    "Content-Type": "application/json",
-                    "User-Agent": "DymoAPISDK/1.0.0",
-                    "X-Dymo-SDK-Env": "Python",
-                    "X-Dymo-SDK-Version": "0.0.60",
-                    "Authorization": token
-                }
-            )
-        resp.raise_for_status()
-        return resp.json()
-    except httpx.RequestError as e: raise APIError(str(e))
+        response = requests.post(
+            f"{get_base_url()}/private/textly/extract",
+            json=data,
+            headers={
+                "Content-Type": "application/json",
+                "User-Agent": "DymoAPISDK/1.0.0",
+                "Authorization": token
+            }
+        )
+        response.raise_for_status()
+        return response.json()
+    except requests.RequestException as e: raise APIError(str(e))

dymoapi/branches/public.py

@@ -1,12 +1,12 @@
-import re, httpx
+import re, requests
 from urllib.parse import quote
 from ..config import get_base_url
 from ..utils.decorators import deprecated
 from ..exceptions import APIError, BadRequestError
 
-headers = {"User-Agent": "DymoAPISDK/1.0.0", "X-Dymo-SDK-Env": "Python", "X-Dymo-SDK-Version" : "0.0.60"}
+headers = {"User-Agent": "DymoAPISDK/1.0.0", "X-Dymo-SDK-Env": "Python", "X-Dymo-SDK-Version" : "0.0.61"}
 
-async def get_prayer_times(data):
+def get_prayer_times(data):
     """
     Gets the prayer times for a given latitude and longitude.
 
@@ -26,14 +26,13 @@ async def get_prayer_times(data):
         "lon": data.get("lon")
     }
     try:
-        async with httpx.AsyncClient() as client:
-            resp = await client.get(f"{get_base_url()}/v1/public/islam/prayertimes", params=params, headers=headers)
-        resp.raise_for_status()
-        return resp.json()
-    except httpx.RequestError as e: raise APIError(str(e))
+        response = requests.get(f"{get_base_url()}/v1/public/islam/prayertimes", params=params)
+        response.raise_for_status()
+        return response.json()
+    except requests.RequestException as e: raise APIError(str(e))
 
 @deprecated("satinize")
-async def satinizer(data):
+def satinizer(data):
     """
     Sanitizes the given input according to the Dymo API standard.
 
@@ -50,17 +49,12 @@ async def satinizer(data):
     try:
         input_value = data.get("input")
         if input_value is None: raise BadRequestError("You must specify at least the input.")
-        async with httpx.AsyncClient() as client:
-            resp = await client.get(
-                f"{get_base_url()}/v1/public/inputSatinizer",
-                params={"input": quote(input_value)},
-                headers=headers
-            )
-        resp.raise_for_status()
-        return resp.json()
-    except httpx.RequestError as e: raise APIError(str(e))
-
-async def satinize(input_value):
+        response = requests.get(f"{get_base_url()}/v1/public/inputSatinizer", params={"input":quote(input_value)}, headers=headers)
+        response.raise_for_status()
+        return response.json()
+    except requests.RequestException as e: raise APIError(str(e))
+
+def satinize(input_value):
     """
     Sanitizes the given input according to the Dymo API standard.
 
@@ -76,17 +70,12 @@ async def satinize(input_value):
     """
     try:
         if input_value is None: raise BadRequestError("You must specify at least the input.")
-        async with httpx.AsyncClient() as client:
-            resp = await client.get(
-                f"{get_base_url()}/v1/public/inputSatinizer",
-                params={"input": quote(input_value)},
-                headers=headers
-            )
-        resp.raise_for_status()
-        return resp.json()
-    except httpx.RequestError as e: raise APIError(str(e))
-
-async def is_valid_pwd(data):
+        response = requests.get(f"{get_base_url()}/v1/public/inputSatinizer", params={"input":quote(input_value)}, headers=headers)
+        response.raise_for_status()
+        return response.json()
+    except requests.RequestException as e: raise APIError(str(e))
+
+def is_valid_pwd(data):
     """
     Validates the given password against the configured deny rules.
 
@@ -124,13 +113,12 @@ async def is_valid_pwd(data):
         if max_length is not None:
             if not isinstance(max_length, int) or max_length < 32 or max_length > 100: raise BadRequestError("If you provide a maximum it must be valid.")
             params["max"] = max_length
-        async with httpx.AsyncClient() as client:
-            resp = await client.get(f"{get_base_url()}/v1/public/validPwd", params=params, headers=headers)
-        resp.raise_for_status()
-        return resp.json()
-    except httpx.RequestError as e: raise APIError(str(e))
+        response = requests.get(f"{get_base_url()}/v1/public/validPwd", params=params, headers=headers)
+        response.raise_for_status()
+        return response.json()
+    except requests.RequestException as e: raise APIError(str(e))
 
-async def new_url_encrypt(url):
+def new_url_encrypt(url):
     """
     Encrypts the given URL.
 
@@ -146,8 +134,7 @@ async def new_url_encrypt(url):
     """
     try:
         if url is None or not (url.startswith("https://") or url.startswith("http://")): raise BadRequestError("You must provide a valid url.")
-        async with httpx.AsyncClient() as client:
-            resp = await client.get(f"{get_base_url()}/v1/public/url-encrypt", params={"url": url}, headers=headers)
-        resp.raise_for_status()
-        return resp.json()
-    except httpx.RequestError as e: raise APIError(str(e))
+        response = requests.get(f"{get_base_url()}/v1/public/url-encrypt", params={"url": url}, headers=headers)
+        response.raise_for_status()
+        return response.json()
+    except requests.RequestException as e: raise APIError(str(e))