✨ publish: async/await

Author: FJRG2007

dymoapi/branches/private.py

@@ -5,23 +5,23 @@
 from ..exceptions import APIError, BadRequestError
 
 @deprecated("is_valid_data_raw")
-def is_valid_data(token, data):
+async 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.58", "Authorization": token})
+        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.59", "Authorization": token})
         response.raise_for_status()
         return response.json()
     except requests.RequestException as e: raise APIError(str(e))
 
-def is_valid_data_raw(token, data):
+async 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:
-        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.58", "Authorization": token})
+        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.59", "Authorization": token})
         response.raise_for_status()
         return response.json()
     except requests.RequestException as e: raise APIError(str(e))
 
-def is_valid_email(token: Optional[str], email: str, rules: Optional[Dict[str, List[str]]] = None) -> Dict[str, Any]:
+async 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.
 
@@ -54,7 +54,7 @@ def is_valid_email(token: Optional[str], email: str, rules: Optional[Dict[str, L
         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.58", "Authorization": token}
+            headers={"User-Agent": "DymoAPISDK/1.0.0", "X-Dymo-SDK-Env": "Python", "X-Dymo-SDK-Version" : "0.0.59", "Authorization": token}
         )
         resp.raise_for_status()
         data = resp.json().get("email", {})
@@ -90,7 +90,7 @@ def is_valid_email(token: Optional[str], email: str, rules: Optional[Dict[str, L
 
     except requests.RequestException as e: raise APIError(f"[Dymo API] {str(e)}")
 
-def is_valid_ip(token: Optional[str], ip: str, rules: Optional[Dict[str, List[str]]] = None) -> Dict[str, Any]:
+async 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.
 
@@ -121,7 +121,7 @@ def is_valid_ip(token: Optional[str], ip: str, rules: Optional[Dict[str, List[st
         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.58", "Authorization": token}
+            headers={"User-Agent": "DymoAPISDK/1.0.0", "X-Dymo-SDK-Env": "Python", "X-Dymo-SDK-Version" : "0.0.59", "Authorization": token}
         )
         resp.raise_for_status()
         data = resp.json().get("ip", {})
@@ -155,7 +155,7 @@ def is_valid_ip(token: Optional[str], ip: str, rules: Optional[Dict[str, List[st
 
     except requests.RequestException as e: raise APIError(f"[Dymo API] {str(e)}")
 
-def is_valid_phone(token: Optional[str], phone: str, rules: Optional[Dict[str, List[str]]] = None) -> Dict[str, Any]:
+async 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.
 
@@ -185,7 +185,7 @@ def is_valid_phone(token: Optional[str], phone: str, rules: Optional[Dict[str, L
         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.58", "Authorization": token}
+            headers={"User-Agent": "DymoAPISDK/1.0.0", "X-Dymo-SDK-Env": "Python", "X-Dymo-SDK-Version" : "0.0.59", "Authorization": token}
         )
         resp.raise_for_status()
         data = resp.json().get("phone", {})
@@ -218,18 +218,18 @@ def is_valid_phone(token: Optional[str], phone: str, rules: Optional[Dict[str, L
 
     except requests.RequestException as e: raise APIError(f"[Dymo API] {str(e)}")
 
-def send_email(token, data):
+async 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:
-        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.58", "Authorization": token})
+        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.59", "Authorization": token})
         response.raise_for_status()
         return response.json()
     except requests.RequestException as e: raise APIError(str(e))
 
-def get_random(token, data):
+async 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.")
@@ -240,13 +240,13 @@ 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:
-        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.58", "Authorization": token})
+        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.59", "Authorization": token})
         response.raise_for_status()
         return response.json()
     except requests.RequestException as e: raise APIError(str(e))
 
 
-def extract_with_textly(token: str, data: dict) -> dict:
+async 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.")
 

dymoapi/branches/public.py

@@ -4,9 +4,9 @@
 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.58"}
+headers = {"User-Agent": "DymoAPISDK/1.0.0", "X-Dymo-SDK-Env": "Python", "X-Dymo-SDK-Version" : "0.0.59"}
 
-def get_prayer_times(data):
+async def get_prayer_times(data):
     """
     Gets the prayer times for a given latitude and longitude.
 
@@ -32,7 +32,7 @@ def get_prayer_times(data):
     except requests.RequestException as e: raise APIError(str(e))
 
 @deprecated("satinize")
-def satinizer(data):
+async def satinizer(data):
     """
     Sanitizes the given input according to the Dymo API standard.
 
@@ -54,7 +54,7 @@ def satinizer(data):
         return response.json()
     except requests.RequestException as e: raise APIError(str(e))
 
-def satinize(input_value):
+async def satinize(input_value):
     """
     Sanitizes the given input according to the Dymo API standard.
 
@@ -75,7 +75,7 @@ def satinize(input_value):
         return response.json()
     except requests.RequestException as e: raise APIError(str(e))
 
-def is_valid_pwd(data):
+async def is_valid_pwd(data):
     """
     Validates the given password against the configured deny rules.
 
@@ -118,7 +118,7 @@ def is_valid_pwd(data):
         return response.json()
     except requests.RequestException as e: raise APIError(str(e))
 
-def new_url_encrypt(url):
+async def new_url_encrypt(url):
     """
     Encrypts the given URL.
 

dymoapi/dymoapi.py

@@ -46,13 +46,13 @@ def __init__(self, config={}):
         self.base_url = get_base_url()
         check_for_updates()
 
-    def _get_function(self, module_name, function_name="main"):
+    async def _get_function(self, module_name, function_name="main"):
         if module_name == "private" and self.api_key is None and self.root_api_key is None: return logging.error("Invalid private token.")
         func = getattr(importlib.import_module(f".branches.{module_name}", package="dymoapi"), function_name)
         if module_name == "private": return lambda *args, **kwargs: DotDict(func(self.api_key or self.root_api_key, *args, **kwargs))
         return lambda *args, **kwargs: DotDict(func(*args, **kwargs))
 
-    def is_valid_data(self, data: response_models.Validator) -> response_models.DataVerifierResponse:
+    async def is_valid_data(self, data: response_models.Validator) -> response_models.DataVerifierResponse:
         """
         Validates the given data against the configured validation settings.
 
@@ -79,15 +79,15 @@ def is_valid_data(self, data: response_models.Validator) -> response_models.Data
 
         [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/data-verifier)
         """
-        response = self._get_function("private", "is_valid_data")(data)
+        response = await self._get_function("private", "is_valid_data")(data)
         if response.get("ip",{}).get("as"):
             response["ip"]["_as"] = response["ip"]["as"]
             response["ip"]["_class"] = response["ip"]["class"]
             response["ip"].pop("as")
             response["ip"].pop("class")
         return response_models.DataVerifierResponse(**response)
 
-    def is_valid_email(self, email: str, rules: dict | None = None) -> bool:
+    async def is_valid_email(self, email: str, rules: dict | None = None) -> bool:
         """
         Wrapper for the private email validation function.
 
@@ -115,9 +115,9 @@ def is_valid_email(self, email: str, rules: dict | None = None) -> bool:
             https://docs.tpeoficial.com/docs/dymo-api/private/email-validation
         """
         rules_to_use = rules or self.rules.get("email")
-        return self._get_function("private", "is_valid_email")(email, rules_to_use)
+        return await self._get_function("private", "is_valid_email")(email, rules_to_use)
 
-    def is_valid_ip(self, ip: str, rules: dict | None = None) -> bool:
+    async def is_valid_ip(self, ip: str, rules: dict | None = None) -> bool:
         """
         Wrapper for the private IP validation function.
 
@@ -145,9 +145,9 @@ def is_valid_ip(self, ip: str, rules: dict | None = None) -> bool:
             https://docs.tpeoficial.com/docs/dymo-api/private/ip-validation
         """
         rules_to_use = rules or self.rules.get("ip")
-        return self._get_function("private", "is_valid_ip")(ip, rules_to_use)
+        return await self._get_function("private", "is_valid_ip")(ip, rules_to_use)
 
-    def is_valid_phone(self, phone: str, rules: dict | None = None) -> bool:
+    async def is_valid_phone(self, phone: str, rules: dict | None = None) -> bool:
         """
         Wrapper for the private phone validation function.
 
@@ -175,9 +175,9 @@ def is_valid_phone(self, phone: str, rules: dict | None = None) -> bool:
             https://docs.tpeoficial.com/docs/dymo-api/private/phone-validation
         """
         rules_to_use = rules or self.rules.get("phone")
-        return self._get_function("private", "is_valid_phone")(phone, rules_to_use)
+        return await self._get_function("private", "is_valid_phone")(phone, rules_to_use)
 
-    def send_email(self, data: response_models.EmailStatus) -> response_models.SendEmailResponse:
+    async def send_email(self, data: response_models.EmailStatus) -> response_models.SendEmailResponse:
         """
         Sends an email using the configured email client settings.
 
@@ -210,9 +210,9 @@ def send_email(self, data: response_models.EmailStatus) -> response_models.SendE
         [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/sender-send-email/getting-started)
         """
         if not self.server_email_config and not self.root_api_key: return logging.error("You must configure the email client settings.")
-        return response_models.DataVerifierResponse(**self._get_function("private", "send_email")({**data, "serverEmailConfig": self.server_email_config}))
+        return response_models.DataVerifierResponse(**await self._get_function("private", "send_email")({**data, "serverEmailConfig": self.server_email_config}))
 
-    def get_random(self, data: response_models.SRNG) -> response_models.SRNGResponse:
+    async def get_random(self, data: response_models.SRNG) -> response_models.SRNGResponse:
         """
         Generates a random number (or numbers) between the provided min and max values.
 
@@ -234,9 +234,9 @@ def get_random(self, data: response_models.SRNG) -> response_models.SRNGResponse
             
         [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/secure-random-number-generator)
         """
-        return response_models.DataVerifierResponse(**self._get_function("private", "get_random")({**data}))
+        return response_models.DataVerifierResponse(**await self._get_function("private", "get_random")({**data}))
 
-    def extract_with_textly(self, data: response_models.Textly) -> response_models.TextlyResponse:
+    async def extract_with_textly(self, data: response_models.Textly) -> response_models.TextlyResponse:
         """
         Extracts structured data from a given text using the Textly endpoint.
 
@@ -258,9 +258,9 @@ def extract_with_textly(self, data: response_models.Textly) -> response_models.T
 
         [Documentation](https://docs.tpeoficial.com/docs/dymo-api/private/extract-textly)
         """        
-        return response_models.ExtractWithTextlyResponse(**self._get_function("private", "extract_with_textly")({**data}))
+        return response_models.ExtractWithTextlyResponse(**await self._get_function("private", "extract_with_textly")({**data}))
 
-    def get_prayer_times(self, data: response_models.PrayerTimesData) -> response_models.PrayerTimesResponse:
+    async def get_prayer_times(self, data: response_models.PrayerTimesData) -> response_models.PrayerTimesResponse:
         """
         Retrieves the prayer times for the given location.
 
@@ -284,9 +284,9 @@ def get_prayer_times(self, data: response_models.PrayerTimesData) -> response_mo
 
         [Documentation](https://docs.tpeoficial.com/docs/dymo-api/public/prayertimes)
         """
-        return response_models.PrayerTimesResponse(**self._get_function("public", "get_prayer_times")(data))
+        return response_models.PrayerTimesResponse(**await self._get_function("public", "get_prayer_times")(data))
 
-    def satinizer(self, data: response_models.InputSanitizerData) -> response_models.SatinizerResponse:
+    async def satinizer(self, data: response_models.InputSanitizerData) -> response_models.SatinizerResponse:
         """
         Sanitizes the input, replacing any special characters with their HTML entities.
 
@@ -304,9 +304,9 @@ def satinizer(self, data: response_models.InputSanitizerData) -> response_models
 
         [Documentation](https://docs.tpeoficial.com/docs/dymo-api/public/input-satinizer)
         """
-        return response_models.SatinizerResponse(**self._get_function("public", "satinizer")(data))
+        return response_models.SatinizerResponse(**await self._get_function("public", "satinizer")(data))
 
-    def is_valid_pwd(self, data: response_models.IsValidPwdData) -> response_models.IsValidPwdResponse:
+    async def is_valid_pwd(self, data: response_models.IsValidPwdData) -> response_models.IsValidPwdResponse:
         """
         Validates a password based on the given parameters.
 
@@ -339,9 +339,9 @@ def is_valid_pwd(self, data: response_models.IsValidPwdData) -> response_models.
 
         [Documentation](https://docs.tpeoficial.com/docs/dymo-api/public/password-validator)
         """
-        return response_models.IsValidPwdResponse(**self._get_function("public", "is_valid_pwd")(data))
+        return response_models.IsValidPwdResponse(**await self._get_function("public", "is_valid_pwd")(data))
 
-    def new_url_encrypt(self, data) -> response_models.UrlEncryptResponse:
-        return response_models.UrlEncryptResponse(**self._get_function("public", "new_url_encrypt")(data))
+    async def new_url_encrypt(self, data) -> response_models.UrlEncryptResponse:
+        return response_models.UrlEncryptResponse(**await self._get_function("public", "new_url_encrypt")(data))
 
 if __name__ == "__main__": sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))

setup.py

@@ -2,7 +2,7 @@
 
 setup(
     name="dymoapi",
-    version="0.0.58",
+    version="0.0.59",
     packages=find_packages(),
     description="Dymo Python API library.",
     long_description=open("README.md").read(),