From f2c61db7d3820d1498cc3ad2972f251f7cbb027f Mon Sep 17 00:00:00 2001 From: Iwakura Lain Date: Fri, 15 May 2020 20:16:53 +0300 Subject: [PATCH] first commit --- main.py | 27 +++ smspva_wrapper/__init__.py | 3 + smspva_wrapper/caller/__init__.py | 1 + smspva_wrapper/caller/caller.py | 52 ++++ smspva_wrapper/client.py | 142 +++++++++++ smspva_wrapper/errors/__init__.py | 25 ++ smspva_wrapper/errors/errors.py | 106 +++++++++ smspva_wrapper/methods/__init__.py | 14 ++ smspva_wrapper/methods/balance_sim.py | 40 ++++ smspva_wrapper/methods/ban.py | 41 ++++ smspva_wrapper/methods/denial.py | 42 ++++ smspva_wrapper/methods/get_2fa.py | 36 +++ smspva_wrapper/methods/get_balance.py | 38 +++ smspva_wrapper/methods/get_clearsms.py | 41 ++++ smspva_wrapper/methods/get_count_new.py | 37 +++ smspva_wrapper/methods/get_number.py | 40 ++++ smspva_wrapper/methods/get_proverka.py | 57 +++++ smspva_wrapper/methods/get_service_price.py | 37 +++ smspva_wrapper/methods/get_sms.py | 55 +++++ smspva_wrapper/methods/get_userinfo.py | 38 +++ smspva_wrapper/methods/helpers/__init__.py | 2 + .../methods/helpers/check_errors.py | 40 ++++ .../methods/helpers/responce_hack.py | 13 + smspva_wrapper/methods/redirect.py | 48 ++++ smspva_wrapper/types/__init__.py | 5 + smspva_wrapper/types/backends.py | 3 + smspva_wrapper/types/containers/__init__.py | 14 ++ .../types/containers/balance_object.py | 17 ++ .../types/containers/balance_sim_object.py | 17 ++ smspva_wrapper/types/containers/ban_object.py | 21 ++ .../types/containers/clearsms_object.py | 17 ++ .../types/containers/count_new_object.py | 33 +++ .../types/containers/denial_object.py | 21 ++ .../types/containers/number_object.py | 21 ++ .../types/containers/proverka_object.py | 17 ++ .../types/containers/redirect_object.py | 16 ++ .../types/containers/service_price_object.py | 29 +++ smspva_wrapper/types/containers/sms_object.py | 21 ++ .../types/containers/two_fa_object.py | 25 ++ .../types/containers/userinfo_object.py | 25 ++ smspva_wrapper/types/countries.py | 80 +++++++ smspva_wrapper/types/operators.py | 11 + smspva_wrapper/types/services.py | 224 ++++++++++++++++++ 43 files changed, 1592 insertions(+) create mode 100644 main.py create mode 100644 smspva_wrapper/__init__.py create mode 100644 smspva_wrapper/caller/__init__.py create mode 100644 smspva_wrapper/caller/caller.py create mode 100644 smspva_wrapper/client.py create mode 100644 smspva_wrapper/errors/__init__.py create mode 100644 smspva_wrapper/errors/errors.py create mode 100644 smspva_wrapper/methods/__init__.py create mode 100644 smspva_wrapper/methods/balance_sim.py create mode 100644 smspva_wrapper/methods/ban.py create mode 100644 smspva_wrapper/methods/denial.py create mode 100644 smspva_wrapper/methods/get_2fa.py create mode 100644 smspva_wrapper/methods/get_balance.py create mode 100644 smspva_wrapper/methods/get_clearsms.py create mode 100644 smspva_wrapper/methods/get_count_new.py create mode 100644 smspva_wrapper/methods/get_number.py create mode 100644 smspva_wrapper/methods/get_proverka.py create mode 100644 smspva_wrapper/methods/get_service_price.py create mode 100644 smspva_wrapper/methods/get_sms.py create mode 100644 smspva_wrapper/methods/get_userinfo.py create mode 100644 smspva_wrapper/methods/helpers/__init__.py create mode 100644 smspva_wrapper/methods/helpers/check_errors.py create mode 100644 smspva_wrapper/methods/helpers/responce_hack.py create mode 100644 smspva_wrapper/methods/redirect.py create mode 100644 smspva_wrapper/types/__init__.py create mode 100644 smspva_wrapper/types/backends.py create mode 100644 smspva_wrapper/types/containers/__init__.py create mode 100644 smspva_wrapper/types/containers/balance_object.py create mode 100644 smspva_wrapper/types/containers/balance_sim_object.py create mode 100644 smspva_wrapper/types/containers/ban_object.py create mode 100644 smspva_wrapper/types/containers/clearsms_object.py create mode 100644 smspva_wrapper/types/containers/count_new_object.py create mode 100644 smspva_wrapper/types/containers/denial_object.py create mode 100644 smspva_wrapper/types/containers/number_object.py create mode 100644 smspva_wrapper/types/containers/proverka_object.py create mode 100644 smspva_wrapper/types/containers/redirect_object.py create mode 100644 smspva_wrapper/types/containers/service_price_object.py create mode 100644 smspva_wrapper/types/containers/sms_object.py create mode 100644 smspva_wrapper/types/containers/two_fa_object.py create mode 100644 smspva_wrapper/types/containers/userinfo_object.py create mode 100644 smspva_wrapper/types/countries.py create mode 100644 smspva_wrapper/types/operators.py create mode 100644 smspva_wrapper/types/services.py diff --git a/main.py b/main.py new file mode 100644 index 0000000..f1eb3f2 --- /dev/null +++ b/main.py @@ -0,0 +1,27 @@ +from smspva_wrapper import Client, Backends, Services, Countries +from smspva_wrapper.types import country_dict, service_dict + +SIMSMS_API_KEY = '' +SMSPVA_API_KEY = '' + +c = Client(api_key=SMSPVA_API_KEY, backend=Backends.SMSPVA) + + +def cheapest_price_finder(): + prices = [] + for country in country_dict: + a = c.get_service_price(Services.TELEGRAM, country) + item = (a.price, a.country) + prices.append(item) + + prices.sort() + for item in prices: + print(f"{item[1]}: {item[0]}") + + +if '__main__' == __name__: + print(c.name) + print(c.balance) + print(c.karma) + print(c.name) + cheapest_price_finder() diff --git a/smspva_wrapper/__init__.py b/smspva_wrapper/__init__.py new file mode 100644 index 0000000..e9327e4 --- /dev/null +++ b/smspva_wrapper/__init__.py @@ -0,0 +1,3 @@ +from smspva_wrapper.client import Client +from smspva_wrapper.errors import Errors +from smspva_wrapper.types import Countries, Services, Backends, Operators diff --git a/smspva_wrapper/caller/__init__.py b/smspva_wrapper/caller/__init__.py new file mode 100644 index 0000000..38f4f77 --- /dev/null +++ b/smspva_wrapper/caller/__init__.py @@ -0,0 +1 @@ +from .caller import caller as caller diff --git a/smspva_wrapper/caller/caller.py b/smspva_wrapper/caller/caller.py new file mode 100644 index 0000000..f55343b --- /dev/null +++ b/smspva_wrapper/caller/caller.py @@ -0,0 +1,52 @@ +import requests +from smspva_wrapper.errors import Errors + + +def caller(query: str) -> dict: + """Low-level function for calling API + + Args: + query (str): API link to request + + Returns: + json_dict (dict): containing dictionary of parsed json from API + + Raises: + InvalidAPIKeyError + InsufficientFundsError + TooShortIntervalError + RepeatRequestLaterError + RequestSyntaxError + APIGeneralError + NetworkingError + UnknownAPIError + """ + r = requests.get(query) + print("Called API") + + if r.status_code == 200: + try: + json_dict: dict = r.json() + return json_dict + except ValueError: + error = r.content.decode() + if 'API KEY не получен!' == error: + raise Errors.InvalidAPIKeyError(error) + elif 'API KEY не найден!' == error: + raise Errors.InvalidAPIKeyError(error) + elif 'API KEY not received!' == error: + raise Errors.InvalidAPIKeyError(error) + elif 'Недостаточно средств!' == error: + raise Errors.InsufficientFundsError(error) + elif 'Превышено количество попыток!' == error: + raise Errors.TooShortIntervalError(error) + elif 'Произошла неизвестная ошибка.' == error: + raise Errors.RepeatRequestLaterError(error) + elif 'Неверный запрос.' == error: + raise Errors.RequestSyntaxError(error) + elif 'Произошла внутренняя ошибка сервера.' == error: + raise Errors.RepeatRequestLaterError(error) + else: + raise Errors.UnknownAPIError(error) + else: + raise Errors.NetworkingError("status code: ", r.status_code) diff --git a/smspva_wrapper/client.py b/smspva_wrapper/client.py new file mode 100644 index 0000000..bcd8c98 --- /dev/null +++ b/smspva_wrapper/client.py @@ -0,0 +1,142 @@ +from typing import Union + +from smspva_wrapper.types import Backends, Services, Countries, Containers +from smspva_wrapper.methods import Methods + + +# noinspection PyCallByClass +class Client: + def __init__(self, api_key: str, backend: Backends): + self._api_base = f'{backend}apikey={api_key}' + self.name = self.me.name + + @property + def api_base(self) -> str: + return str(self._api_base) + + @property + def me(self) -> Containers.UserInfo: + return self.get_userinfo() + + @property + def balance(self) -> float: + return float(self.me.balance) + + @property + def karma(self) -> float: + return float(self.me.karma) + + def get_balance(self) -> Containers.Balance: + return Containers.Balance( + Methods.get_balance( + api_base=self.api_base + ) + ) + + def get_userinfo(self) -> Containers.UserInfo: + return Containers.UserInfo( + Methods.get_userinfo( + api_base=self.api_base + ) + ) + + def get_count_new(self, service: Union[Services, str], country: Union[Countries, str]) -> Containers.CountNew: + return Containers.CountNew( + Methods.get_count_new( + api_base=self.api_base, + service=str(service), + country=str(country) + ) + ) + + def get_service_price(self, service: Union[Services, str], country: Union[Countries, str]) -> Containers.ServicePrice: + return Containers.ServicePrice( + Methods.get_service_price( + api_base=self.api_base, + service=str(service), + country=str(country) + ) + ) + + def get_number(self, service: Union[Services, str], country: Union[Countries, str]) -> Containers.Number: + return Containers.Number( + Methods.get_number( + api_base=self.api_base, + service=str(service), + country=str(country) + ) + ) + + def ban(self, service: Union[Services, str], _id: str) -> Containers.Ban: + return Containers.Ban( + Methods.ban( + api_base=self.api_base, + service=str(service), + _id=_id + ) + ) + + def get_sms(self, service: Union[Services, str], country: Union[Countries, str], _id: str) -> Containers.SMS: + return Containers.SMS( + Methods.get_sms( + api_base=self.api_base, + service=str(service), + country=str(country), + _id=_id + ) + ) + + def denial(self, service: Union[Services, str], country: Union[Countries, str], _id: str) -> Containers.Denial: + return Containers.Denial( + Methods.denial( + api_base=self.api_base, + service=str(service), + country=str(country), + _id=_id + ) + ) + + def get_proveka(self, service: Union[Services, str], number: str) -> Containers.Proverka: + return Containers.Proverka( + Methods.get_proverka( + api_base=self.api_base, + service=str(service), + number=number + ) + ) + + def balance_sim(self, service: Union[Services, str], _id: str) -> Containers.BalanceSIM: + return Containers.BalanceSIM( + Methods.balance_sim( + api_base=self.api_base, + service=str(service), + _id=_id + ) + ) + + def redirect(self, service: Union[Services, str], number_redirect: str, _id: str) -> Containers.Redirect: + return Containers.Redirect( + Methods.redirect( + api_base=self.api_base, + service=str(service), + _id=_id, + number_redirect=number_redirect + ) + ) + + def get_2fa(self, secret: str) -> Containers.TwoFA: + return Containers.TwoFA( + Methods.get_2fa( + api_base=self.api_base, + secret=str(secret) + ) + ) + + def get_clearsms(self, service: Union[Services, str], _id: str) -> Containers.ClearSMS: + return Containers.ClearSMS( + Methods.get_clearsms( + api_base=self.api_base, + service=str(service), + _id=_id + ) + ) diff --git a/smspva_wrapper/errors/__init__.py b/smspva_wrapper/errors/__init__.py new file mode 100644 index 0000000..d83d8c5 --- /dev/null +++ b/smspva_wrapper/errors/__init__.py @@ -0,0 +1,25 @@ +class Errors: + from .errors import GeneralError + from .errors import NetworkingError + from .errors import APIError + from .errors import UnknownAPIError + from .errors import MaxRequestsPerMinuteError + from .errors import NegativeKarmaError + from .errors import MaxConcurrentStreamsError + from .errors import InvalidAPIKeyError + from .errors import InsufficientFundsError + from .errors import TooShortIntervalError + from .errors import RepeatRequestLaterError + from .errors import RequestSyntaxError + from .errors import UserInfoError + from .errors import NumberAlreadyTakenError + from .errors import BanError + from .errors import GetSMSError + from .errors import DenialFailedError + from .errors import ClearSMSError + from .errors import BalanceSIMError + from .errors import ProverkaNumberForServiceError + from .errors import ProverkaGSMBusyError + from .errors import ProverkaNumberError + from .errors import RedirectFailError + from .errors import RedirectInvalidNumberFormat diff --git a/smspva_wrapper/errors/errors.py b/smspva_wrapper/errors/errors.py new file mode 100644 index 0000000..00228d0 --- /dev/null +++ b/smspva_wrapper/errors/errors.py @@ -0,0 +1,106 @@ +class GeneralError(Exception): + """Base class for exceptions in this module.""" + + +class NetworkingError(GeneralError): + """Networking Error""" + + +# API errors +class APIError(GeneralError): + """Base class for API error""" + + +class UnknownAPIError(APIError): + """Unknown API error""" + + +# Return code errors +class MaxRequestsPerMinuteError(APIError): + """You have exceeded the number of requests per minute""" + + +class NegativeKarmaError(APIError): + """You will be banned for 10 minutes, because scored negative karma""" + + +class MaxConcurrentStreamsError(APIError): + """You have exceeded the number of concurrent streams. SMS Wait from previous orders""" + + +class InvalidAPIKeyError(APIError): + """Invalid API KEY has been entered""" + + +class InsufficientFundsError(APIError): + """Insufficient funds""" + + +class TooShortIntervalError(APIError): + """Set a longer interval between calls to API server""" + + +class RepeatRequestLaterError(APIError): + """Try to repeat your request later.""" + + +class RequestSyntaxError(APIError): + """Check the request syntax and the list of parameters used (can be found on the page with method description).""" + + +# Method errors +# get_balance, get_userinfo +class UserInfoError(APIError): + """Not ID or user balance""" + + +# get_number +class NumberAlreadyTakenError(APIError): + """Number is already taken""" + + +# ban +class BanError(APIError): + """Ban request has failed""" + + +# get_sms +class GetSMSError(APIError): + """No such SMS or invalid request ID or SMS waiting time has expired (no more than 10 minutes)""" + + +# denial +class DenialFailedError(APIError): + """Denial request has failed""" + + +# clearsms +class ClearSMSError(APIError): + """ClearSMS error""" + + +# balance_sim +class BalanceSIMError(APIError): + """SIM card balance info hasn't been received""" + + +# get_proverka errors +class ProverkaNumberForServiceError(APIError): + """You didn't order a number for this service""" + + +class ProverkaGSMBusyError(APIError): + """GSM module is busy try to repeat your request 5 minutes later""" + + +class ProverkaNumberError(APIError): + """There's no such number in the system any longer""" + + +# redirect errors +class RedirectFailError(APIError): + """Redirecting failed""" + + +class RedirectInvalidNumberFormat(APIError): + """Invalid number format for redirecting""" diff --git a/smspva_wrapper/methods/__init__.py b/smspva_wrapper/methods/__init__.py new file mode 100644 index 0000000..759b4b2 --- /dev/null +++ b/smspva_wrapper/methods/__init__.py @@ -0,0 +1,14 @@ +class Methods: + from .balance_sim import balance_sim + from .ban import ban + from .denial import denial + from .get_2fa import get_2fa + from .get_balance import get_balance + from .get_clearsms import get_clearsms + from .get_count_new import get_count_new + from .get_number import get_number + from .get_proverka import get_proverka + from .get_service_price import get_service_price + from .get_sms import get_sms + from .get_userinfo import get_userinfo + from .redirect import redirect diff --git a/smspva_wrapper/methods/balance_sim.py b/smspva_wrapper/methods/balance_sim.py new file mode 100644 index 0000000..c4034f1 --- /dev/null +++ b/smspva_wrapper/methods/balance_sim.py @@ -0,0 +1,40 @@ +from smspva_wrapper.caller import caller +from smspva_wrapper.methods.helpers import responce_hack, check_errors +from smspva_wrapper.errors import Errors + + +def balance_sim(api_base: str, service: str, _id: str) -> dict: + """Low level function to receive SIM card balance for avito+forwarding service. + + Args: + api_base (str): "http://smspva.com/priemnik.php?apikey=DSWAFvdedrE4" + service (str): "opt59" + _id (str): "25623" + + Returns: + dict: provides an API call dictionary + + Raises: + InvalidAPIKeyError + InsufficientFundsError + TooShortIntervalError + RepeatRequestLaterError + RequestSyntaxError + UnknownAPIError + NetworkingError + MaxRequestsPerMinuteError + NegativeKarmaError + MaxConcurrentStreamsError + BalanceSIMError + """ + + q = f"{api_base}&metod=balance_sim&service={service}&id={_id}" + r = caller(q) + c = responce_hack(r) + + if check_errors(c) is True: + return c + elif c['response'] == '2': + raise Errors.BalanceSIMError(c['amount'], c) + else: + raise Errors.UnknownAPIError(c) diff --git a/smspva_wrapper/methods/ban.py b/smspva_wrapper/methods/ban.py new file mode 100644 index 0000000..b59ce8d --- /dev/null +++ b/smspva_wrapper/methods/ban.py @@ -0,0 +1,41 @@ +from smspva_wrapper.caller import caller +from smspva_wrapper.methods.helpers import responce_hack, check_errors +from smspva_wrapper.errors import Errors + + +def ban(api_base: str, service: str, _id: str) -> dict: + """Low level function to report to the server that the number is already used + In this method id parameter is indicated from the response to request for phone number get_number + + Args: + api_base (str): "http://smspva.com/priemnik.php?apikey=DSWAFvdedrE4" + service (str): "opt4" + _id (str): "25623" + + Returns: + dict: API call dictionary + + Raises: + InvalidAPIKeyError + InsufficientFundsError + TooShortIntervalError + RepeatRequestLaterError + RequestSyntaxError + UnknownAPIError + NetworkingError + MaxRequestsPerMinuteError + NegativeKarmaError + MaxConcurrentStreamsError + BanFailedError + """ + + q = f"{api_base}&metod=ban&service={service}&id={_id}" + r = caller(q) + c = responce_hack(r) + + if check_errors(c) is True: + return c + elif c['response'] == '2': + raise Errors.BanError(c) + else: + raise Errors.UnknownAPIError(c) diff --git a/smspva_wrapper/methods/denial.py b/smspva_wrapper/methods/denial.py new file mode 100644 index 0000000..98d0316 --- /dev/null +++ b/smspva_wrapper/methods/denial.py @@ -0,0 +1,42 @@ +from smspva_wrapper.caller import caller +from smspva_wrapper.methods.helpers import responce_hack, check_errors +from smspva_wrapper.errors import Errors + + +def denial(api_base: str, service: str, country: str, _id: str) -> dict: + """Low level function to cancel the order to number you got + In this method id parameter is indicated from the response to request for phone number get_number + + Args: + api_base (str): "http://smspva.com/priemnik.php?apikey=DSWAFvdedrE4" + service (str): "opt4" + country (str): "ru" + _id (str): "25623" + + Returns: + dict: API call dictionary + + Raises: + InvalidAPIKeyError + InsufficientFundsError + TooShortIntervalError + RepeatRequestLaterError + RequestSyntaxError + UnknownAPIError + NetworkingError + MaxRequestsPerMinuteError + NegativeKarmaError + MaxConcurrentStreamsError + DenialFailedError + """ + + q = f"{api_base}&metod=denial&service={service}&country={country}&id={_id}" + r = caller(q) + c = responce_hack(r) + + if check_errors(c) is True: + return c + elif c['response'] == '2': + raise Errors.DenialFailedError(c) + else: + raise Errors.UnknownAPIError(c) diff --git a/smspva_wrapper/methods/get_2fa.py b/smspva_wrapper/methods/get_2fa.py new file mode 100644 index 0000000..8246f01 --- /dev/null +++ b/smspva_wrapper/methods/get_2fa.py @@ -0,0 +1,36 @@ +from smspva_wrapper.caller import caller +from smspva_wrapper.methods.helpers import responce_hack, check_errors +from smspva_wrapper.errors import Errors + + +def get_2fa(api_base: str, secret: str) -> dict: + """Low level function for obtaining 2FA authorization code from Google, Microsoft, etc. by secret key + + Args: + api_base (str): "http://smspva.com/priemnik.php?apikey=DSWAFvdedrE4" + secret (str): "1234567890" + + Returns: + dict: API call dictionary + + Raises: + InvalidAPIKeyError + InsufficientFundsError + TooShortIntervalError + RepeatRequestLaterError + RequestSyntaxError + UnknownAPIError + NetworkingError + MaxRequestsPerMinuteError + NegativeKarmaError + MaxConcurrentStreamsError + """ + + q = f"{api_base}&metod=get_2fa&secret={secret}" + r = caller(q) + c = responce_hack(r) + + if check_errors(c) is True: + return c + else: + raise Errors.UnknownAPIError(c) diff --git a/smspva_wrapper/methods/get_balance.py b/smspva_wrapper/methods/get_balance.py new file mode 100644 index 0000000..603f165 --- /dev/null +++ b/smspva_wrapper/methods/get_balance.py @@ -0,0 +1,38 @@ +from smspva_wrapper.caller import caller +from smspva_wrapper.methods.helpers import responce_hack, check_errors +from smspva_wrapper.errors import Errors + + +def get_balance(api_base: str) -> dict: + """Low level function that returns balance of the account + + Args: + api_base (str): "http://smspva.com/priemnik.php?apikey=DSWAFvdedrE4" + + Returns: + dict: API call dictionary + + Raises: + InvalidAPIKeyError + InsufficientFundsError + TooShortIntervalError + RepeatRequestLaterError + RequestSyntaxError + UnknownAPIError + NetworkingError + MaxRequestsPerMinuteError + NegativeKarmaError + MaxConcurrentStreamsError + UserInfoError + """ + + q = f"{api_base}&metod=get_balance" + r = caller(q) + c = responce_hack(r) + + if check_errors(c) is True: + return c + elif c['response'] == 'error': + raise Errors.UserInfoError(c['error_msg'], c) + else: + raise Errors.UnknownAPIError(c) diff --git a/smspva_wrapper/methods/get_clearsms.py b/smspva_wrapper/methods/get_clearsms.py new file mode 100644 index 0000000..c43c8b7 --- /dev/null +++ b/smspva_wrapper/methods/get_clearsms.py @@ -0,0 +1,41 @@ +from smspva_wrapper.caller import caller +from smspva_wrapper.methods.helpers import responce_hack, check_errors +from smspva_wrapper.errors import Errors + + +def get_clearsms(api_base: str, service: str, _id: str) -> dict: + """SIMSMS ONLY! Low level function to check the number to receive several SMS consecutively within one order + In this method, the parameter id indicates the order number within which you need to receive another text. + + Args: + api_base (str): "http://simsms.org/priemnik.php?apikey=DSWAFvdedrE4" + service (str): "opt4" + _id (str): "25623" + + Returns: + dict: API call dictionary + + Raises: + InvalidAPIKeyError + InsufficientFundsError + TooShortIntervalError + RepeatRequestLaterError + RequestSyntaxError + UnknownAPIError + NetworkingError + MaxRequestsPerMinuteError + NegativeKarmaError + MaxConcurrentStreamsError + ClearSMSError + """ + + q = f"{api_base}&metod=get_clearsms&service={service}&id={_id}" + r = caller(q) + c = responce_hack(r) + + if check_errors(c) is True: + return c + elif c['response'] == '2': + raise Errors.ClearSMSError(c) + else: + raise Errors.UnknownAPIError(c) diff --git a/smspva_wrapper/methods/get_count_new.py b/smspva_wrapper/methods/get_count_new.py new file mode 100644 index 0000000..5858695 --- /dev/null +++ b/smspva_wrapper/methods/get_count_new.py @@ -0,0 +1,37 @@ +from smspva_wrapper.caller import caller +from smspva_wrapper.methods.helpers import responce_hack, check_errors +from smspva_wrapper.errors import Errors + + +def get_count_new(api_base: str, service: str, country: str) -> dict: + """Low level function to request for the amount of free activations for a certain service + + Args: + api_base (str): "http://smspva.com/priemnik.php?apikey=DSWAFvdedrE4" + service (str): "opt4" + country (str): "ru" + + Returns: + dict: API call dictionary + + Raises: + InvalidAPIKeyError + InsufficientFundsError + TooShortIntervalError + RepeatRequestLaterError + RequestSyntaxError + UnknownAPIError + NetworkingError + MaxRequestsPerMinuteError + NegativeKarmaError + MaxConcurrentStreamsError + """ + + q = f"{api_base}&metod=get_count_new&service={service}&country={country}" + r = caller(q) + c = responce_hack(r) + + if check_errors(c) is True: + return c + else: + raise Errors.UnknownAPIError(c) diff --git a/smspva_wrapper/methods/get_number.py b/smspva_wrapper/methods/get_number.py new file mode 100644 index 0000000..bae3310 --- /dev/null +++ b/smspva_wrapper/methods/get_number.py @@ -0,0 +1,40 @@ +from smspva_wrapper.caller import caller +from smspva_wrapper.methods.helpers import responce_hack, check_errors +from smspva_wrapper.errors import Errors + + +def get_number(api_base: str, service: str, country: str) -> dict: + """Low level function to receive a phone number for a certain service. + + Args: + api_base (str): "http://smspva.com/priemnik.php?apikey=DSWAFvdedrE4" + service (str): "opt4" + country (str): "ru" + + Returns: + dict: API call dictionary + + Raises: + InvalidAPIKeyError + InsufficientFundsError + TooShortIntervalError + RepeatRequestLaterError + RequestSyntaxError + UnknownAPIError + NetworkingError + MaxRequestsPerMinuteError + NegativeKarmaError + MaxConcurrentStreamsError + NumberAlreadyTakenError + """ + + q = f"{api_base}&metod=get_number&service={service}&country={country}" + r = caller(q) + c = responce_hack(r) + + if check_errors(c) is True: + return c + elif c['response'] == '2': + raise Errors.NumberAlreadyTakenError(c) + else: + raise Errors.UnknownAPIError(c) diff --git a/smspva_wrapper/methods/get_proverka.py b/smspva_wrapper/methods/get_proverka.py new file mode 100644 index 0000000..29a22af --- /dev/null +++ b/smspva_wrapper/methods/get_proverka.py @@ -0,0 +1,57 @@ +from smspva_wrapper.caller import caller +from smspva_wrapper.methods.helpers import responce_hack, check_errors +from smspva_wrapper.errors import Errors + + +def get_proverka(api_base: str, service: str, number: str) -> dict: + """Low level function for checking the numbers for multiple SMS + In this method, number parameter specifies the number that you want to check. + + Note: + Following the successful check of a number, send a request for getting the number - get_number ALSO with number parameter.\ + To check SMS send a request for SMS get_sms according to conditions + + + Args: + api_base (str): "http://smspva.com/priemnik.php?apikey=DSWAFvdedrE4" + service (str): "opt4" + number (str): "9685156912" + + Returns: + dict: API call dictionary + + Raises: + InvalidAPIKeyError + InsufficientFundsError + TooShortIntervalError + RepeatRequestLaterError + RequestSyntaxError + UnknownAPIError + NetworkingError + MaxRequestsPerMinuteError + NegativeKarmaError + MaxConcurrentStreamsError + ProverkaGSMModuleBusyError + ProverkaNoOrderForNumberForServiceError + ProverkaNoSuchNumberError + """ + + q = f"{api_base}&metod=get_proverka&service={service}&id={number}" + r = caller(q) + c = responce_hack(r) + + if check_errors(c) is True: + return c + else: + e_msg = c['error_msg'] + if e_msg == 'Number shall consist of 10 digits!': + raise Errors.ProverkaNumberForServiceError(c) + elif e_msg == 'Such a number you did not order for the service': + raise Errors.ProverkaNumberForServiceError(c) + elif e_msg == 'The modem is busy, try to order in 5 minutes': + raise Errors.ProverkaGSMBusyError(c) + elif 'not_number' in c: + if c['not_number'] == 'This number is no longer in the system': + raise Errors.ProverkaNumberError(c) + else: + raise Errors.UnknownAPIError(c) diff --git a/smspva_wrapper/methods/get_service_price.py b/smspva_wrapper/methods/get_service_price.py new file mode 100644 index 0000000..0b36719 --- /dev/null +++ b/smspva_wrapper/methods/get_service_price.py @@ -0,0 +1,37 @@ +from smspva_wrapper.caller import caller +from smspva_wrapper.methods.helpers import responce_hack, check_errors +from smspva_wrapper.errors import Errors + + +def get_service_price(api_base: str, service: str, country: str) -> dict: + """Low level function to request current price sms for country and service + + Args: + api_base (str): "http://smspva.com/priemnik.php?apikey=DSWAFvdedrE4" + service (str): "opt4" + country (str): "ru" + + Returns: + dict: API call dictionary + + Raises: + InvalidAPIKeyError + InsufficientFundsError + TooShortIntervalError + RepeatRequestLaterError + RequestSyntaxError + UnknownAPIError + NetworkingError + MaxRequestsPerMinuteError + NegativeKarmaError + MaxConcurrentStreamsError + """ + + q = f"{api_base}&metod=get_service_price&service={service}&country={country}" + r = caller(q) + c = responce_hack(r) + + if check_errors(c) is True: + return c + else: + raise Errors.UnknownAPIError(c) diff --git a/smspva_wrapper/methods/get_sms.py b/smspva_wrapper/methods/get_sms.py new file mode 100644 index 0000000..120cc5f --- /dev/null +++ b/smspva_wrapper/methods/get_sms.py @@ -0,0 +1,55 @@ +from smspva_wrapper.caller import caller +from smspva_wrapper.methods.helpers import responce_hack, check_errors +from smspva_wrapper.errors import Errors + + +def get_sms(api_base: str, service: str, country: str, _id: str, sms: bool = False) -> dict: + """Low level function for receiving a SMS for a certain service + In this method id parameter is indicated from the response to request for phone number get_number + + Note: + If you get the response that a code from SMS hasn't been found yet, send request get_sms once again 20 seconds later.\ + Note, the server searches for SMS for 10 minutes. You need to send your request within 10 minutes each 20 seconds per one request.\ + That said, you receive a code from SMS or error message. + If you want to get re-SMS without closing the order (Code Refinement), then set sms parameter to True \ + In this case, your order can not be closed and you may receive a re-SMS. Re-chargeable SMS. The cost is the cost of an ordinary SMS for this service. + + Args: + api_base (str): "http://smspva.com/priemnik.php?apikey=DSWAFvdedrE4" + service (str): "opt4" + country (str): "ru" + _id (str): "25623" + sms (bool): False + + Returns: + dict: API call dictionary + + Raises: + InvalidAPIKeyError + InsufficientFundsError + TooShortIntervalError + RepeatRequestLaterError + RequestSyntaxError + UnknownAPIError + NetworkingError + MaxRequestsPerMinuteError + NegativeKarmaError + MaxConcurrentStreamsError + GetSMSError + """ + + q = f"{api_base}&metod=get_sms&service={service}&country={country}&id={_id}" + if sms: + q = f"{q}&sms=sms" + + r = caller(q) + c = responce_hack(r) + + if check_errors(c) is True: + return c + elif c['response'] == '2': + return c + elif c['response'] == '3': + raise Errors.GetSMSError(c) + else: + raise Errors.UnknownAPIError(c) diff --git a/smspva_wrapper/methods/get_userinfo.py b/smspva_wrapper/methods/get_userinfo.py new file mode 100644 index 0000000..fdfd9ea --- /dev/null +++ b/smspva_wrapper/methods/get_userinfo.py @@ -0,0 +1,38 @@ +from smspva_wrapper.caller import caller +from smspva_wrapper.methods.helpers import responce_hack, check_errors +from smspva_wrapper.errors import Errors + + +def get_userinfo(api_base: str) -> dict: + """Low level function to request user's balance and karma + + Args: + api_base (str): "http://smspva.com/priemnik.php?apikey=DSWAFvdedrE4" + + Returns: + dict: API call dictionary + + Raises: + InvalidAPIKeyError + InsufficientFundsError + TooShortIntervalError + RepeatRequestLaterError + RequestSyntaxError + UnknownAPIError + NetworkingError + MaxRequestsPerMinuteError + NegativeKarmaError + MaxConcurrentStreamsError + UserInfoError + """ + + q = f"{api_base}&metod=get_userinfo" + r = caller(q) + c = responce_hack(r) + + if check_errors(c) is True: + return c + elif c['response'] == 'error': + raise Errors.UserInfoError(c['error_msg'], c) + else: + raise Errors.UnknownAPIError(c) diff --git a/smspva_wrapper/methods/helpers/__init__.py b/smspva_wrapper/methods/helpers/__init__.py new file mode 100644 index 0000000..0d2c3a6 --- /dev/null +++ b/smspva_wrapper/methods/helpers/__init__.py @@ -0,0 +1,2 @@ +from .check_errors import check_errors +from .responce_hack import responce_hack diff --git a/smspva_wrapper/methods/helpers/check_errors.py b/smspva_wrapper/methods/helpers/check_errors.py new file mode 100644 index 0000000..07c6aa4 --- /dev/null +++ b/smspva_wrapper/methods/helpers/check_errors.py @@ -0,0 +1,40 @@ +from smspva_wrapper.errors import Errors + + +def check_errors(d: dict) -> bool: + """Checks for error codes in dict + + Args: + d(dict): Takes in dictionary from API + + Returns: + bool: True if no errors were found. False otherwise + + Raises: + UnknownAPIError + MaxRequestsPerMinuteError + NegativeKarmaError + MaxConcurrentStreamsError + """ + + response_code = d.get('response', '') + if response_code == '1': + return True + if response_code == '2': + return False + elif response_code == '3': + return False + elif response_code == '4': + raise Errors.UnknownAPIError(d) + elif response_code == '5': + raise Errors.MaxRequestsPerMinuteError(d) + elif response_code == '6': + raise Errors.NegativeKarmaError(d) + elif response_code == '7': + raise Errors.MaxConcurrentStreamsError(d) + elif response_code == 'error': + return False + elif response_code == 'modem_busy': + return False + else: + return False diff --git a/smspva_wrapper/methods/helpers/responce_hack.py b/smspva_wrapper/methods/helpers/responce_hack.py new file mode 100644 index 0000000..05ce2b0 --- /dev/null +++ b/smspva_wrapper/methods/helpers/responce_hack.py @@ -0,0 +1,13 @@ +def responce_hack(d: dict) -> dict: + """Shitty hack to fix inconsistencies in API responses + + Args: + d (dict): takes in dictionary from API call + + Returns: + d (dict): returns fixed dictionary + """ + if 'responce' in d: + d['response'] = d.pop('responce') + + return d diff --git a/smspva_wrapper/methods/redirect.py b/smspva_wrapper/methods/redirect.py new file mode 100644 index 0000000..910ffce --- /dev/null +++ b/smspva_wrapper/methods/redirect.py @@ -0,0 +1,48 @@ +from smspva_wrapper.caller import caller +from smspva_wrapper.methods.helpers import responce_hack, check_errors +from smspva_wrapper.errors import Errors + + +def redirect(api_base: str, service: str, _id: str, number_redirect: str) -> dict: + """Low level function for number forwarding + This method works only for avito+forwarding service. + + Note: + Indicate the number for forwarding in the parameter number_redirect! + + Args: + api_base (str): "http://smspva.com/priemnik.php?apikey=DSWAFvdedrE4" + service (str): "opt59" + _id (str): "25623" + number_redirect (str): "9869788422" + + Returns: + dict: API call dictionary + + Raises: + InvalidAPIKeyError + InsufficientFundsError + TooShortIntervalError + RepeatRequestLaterError + RequestSyntaxError + UnknownAPIError + NetworkingError + MaxRequestsPerMinuteError + NegativeKarmaError + MaxConcurrentStreamsError + RedirectInvalidNumberFormat + RedirectFailError + """ + + q = f"{api_base}&service={service}&id={_id}&number_redirect={number_redirect}" + r = caller(q) + c = responce_hack(r) + + if check_errors(c) is True: + return c + elif c['response'] == '2': + raise Errors.RedirectInvalidNumberFormat(c['forwarding'], c) + elif c['response'] == '3': + raise Errors.RedirectFailError(c['forwarding'], c) + else: + raise Errors.UnknownAPIError(c) diff --git a/smspva_wrapper/types/__init__.py b/smspva_wrapper/types/__init__.py new file mode 100644 index 0000000..fc663c8 --- /dev/null +++ b/smspva_wrapper/types/__init__.py @@ -0,0 +1,5 @@ +from .countries import Countries, country_dict +from .services import Services, service_dict +from .operators import Operators +from .backends import Backends +from .containers import Containers diff --git a/smspva_wrapper/types/backends.py b/smspva_wrapper/types/backends.py new file mode 100644 index 0000000..ed96049 --- /dev/null +++ b/smspva_wrapper/types/backends.py @@ -0,0 +1,3 @@ +class Backends: + SMSPVA = 'http://smspva.com/priemnik.php?' + SIMSMS = 'https://simsms.org/priemnik.php?' diff --git a/smspva_wrapper/types/containers/__init__.py b/smspva_wrapper/types/containers/__init__.py new file mode 100644 index 0000000..7f23dfb --- /dev/null +++ b/smspva_wrapper/types/containers/__init__.py @@ -0,0 +1,14 @@ +class Containers: + from .balance_object import Balance as Balance + from .balance_sim_object import BalanceSIM as BalanceSIM + from .ban_object import Ban as Ban + from .denial_object import Denial as Denial + from .count_new_object import CountNew as CountNew + from .number_object import Number as Number + from .proverka_object import Proverka as Proverka + from .redirect_object import Redirect as Redirect + from .service_price_object import ServicePrice as ServicePrice + from .sms_object import SMS as SMS + from .two_fa_object import TwoFA as TwoFA + from .userinfo_object import UserInfo as UserInfo + from .clearsms_object import ClearSMS as ClearSMS diff --git a/smspva_wrapper/types/containers/balance_object.py b/smspva_wrapper/types/containers/balance_object.py new file mode 100644 index 0000000..250cd6d --- /dev/null +++ b/smspva_wrapper/types/containers/balance_object.py @@ -0,0 +1,17 @@ +class Balance(object): + """Immutable high level container for get_balance query""" + + def __init__(self, data: dict): + self._data = data + + @property + def data(self) -> dict: + return self._data + + @property + def response(self) -> int: + return int(self._data.get('response')) + + @property + def balance(self) -> float: + return float(self._data.get('balance')) diff --git a/smspva_wrapper/types/containers/balance_sim_object.py b/smspva_wrapper/types/containers/balance_sim_object.py new file mode 100644 index 0000000..ea9ed7d --- /dev/null +++ b/smspva_wrapper/types/containers/balance_sim_object.py @@ -0,0 +1,17 @@ +class BalanceSIM(object): + """Immutable high level container for balance_sim query""" + + def __init__(self, data: dict): + self._data = data + + @property + def data(self) -> dict: + return self._data + + @property + def response(self) -> int: + return int(self._data.get('response')) + + @property + def balance(self) -> float: + return float(self._data.get('amount')) diff --git a/smspva_wrapper/types/containers/ban_object.py b/smspva_wrapper/types/containers/ban_object.py new file mode 100644 index 0000000..d92f4f4 --- /dev/null +++ b/smspva_wrapper/types/containers/ban_object.py @@ -0,0 +1,21 @@ +class Ban(object): + """Immutable high level container for ban query""" + + def __init__(self, data: dict): + self._data = data + + @property + def data(self) -> dict: + return self._data + + @property + def response(self) -> int: + return int(self._data.get('response')) + + @property + def number(self) -> str: + return self._data.get('number') + + @property + def id(self) -> str: + return self._data.get('id') diff --git a/smspva_wrapper/types/containers/clearsms_object.py b/smspva_wrapper/types/containers/clearsms_object.py new file mode 100644 index 0000000..9821719 --- /dev/null +++ b/smspva_wrapper/types/containers/clearsms_object.py @@ -0,0 +1,17 @@ +class ClearSMS: + """Immutable high level container for clearsms query""" + + def __init__(self, data: dict): + self._data = data + + @property + def data(self) -> dict: + return self._data + + @property + def response(self) -> int: + return int(self._data.get('number')) + + @property + def clearsms(self) -> str: + return self._data.get('clearsms') diff --git a/smspva_wrapper/types/containers/count_new_object.py b/smspva_wrapper/types/containers/count_new_object.py new file mode 100644 index 0000000..bc769a5 --- /dev/null +++ b/smspva_wrapper/types/containers/count_new_object.py @@ -0,0 +1,33 @@ +from ..countries import Countries, country_dict +from ..services import Services, service_dict + + +class CountNew: + """Immutable high level container for get_count_new query""" + + def __init__(self, data: dict): + self._data = data + + @property + def data(self) -> dict: + return self._data + + @property + def online(self) -> int: + return int(self._data.get('online')) + + @property + def total(self) -> int: + return int(self._data.get('total')) + + @property + def for_total(self) -> int: + return int(self._data.get('forTotal')) + + @property + def country(self) -> Countries: + return country_dict.get(self._data.get('country')) + + @property + def service(self) -> Services: + return service_dict.get(self._data.get('Service')) diff --git a/smspva_wrapper/types/containers/denial_object.py b/smspva_wrapper/types/containers/denial_object.py new file mode 100644 index 0000000..7eb6b76 --- /dev/null +++ b/smspva_wrapper/types/containers/denial_object.py @@ -0,0 +1,21 @@ +class Denial: + """Immutable high level container for denial query""" + + def __init__(self, data: dict): + self._data = data + + @property + def data(self) -> dict: + return self._data + + @property + def response(self) -> int: + return int(self._data.get('response')) + + @property + def number(self) -> str: + return self._data.get('response') + + @property + def id(self) -> str: + return self._data.get('id') diff --git a/smspva_wrapper/types/containers/number_object.py b/smspva_wrapper/types/containers/number_object.py new file mode 100644 index 0000000..f4124f6 --- /dev/null +++ b/smspva_wrapper/types/containers/number_object.py @@ -0,0 +1,21 @@ +class Number: + """Immutable high level container for get_number query""" + + def __init__(self, data: dict): + self._data = data + + @property + def data(self) -> dict: + return self._data + + @property + def response(self) -> int: + return int(self._data.get('response')) + + @property + def number(self) -> str: + return self._data.get('number') + + @property + def id(self) -> str: + return self._data.get('id') diff --git a/smspva_wrapper/types/containers/proverka_object.py b/smspva_wrapper/types/containers/proverka_object.py new file mode 100644 index 0000000..62a868c --- /dev/null +++ b/smspva_wrapper/types/containers/proverka_object.py @@ -0,0 +1,17 @@ +class Proverka: + """Immutable high level container for get_proverka""" + + def __init__(self, data: dict): + self._data = data + + @property + def data(self) -> dict: + return self._data + + @property + def number(self) -> str: + return self._data.get('number') + + @property + def sms(self) -> str: + return self._data.get('sms') diff --git a/smspva_wrapper/types/containers/redirect_object.py b/smspva_wrapper/types/containers/redirect_object.py new file mode 100644 index 0000000..b361be1 --- /dev/null +++ b/smspva_wrapper/types/containers/redirect_object.py @@ -0,0 +1,16 @@ +class Redirect: + """Immutable high level container for redirect""" + + def __init__(self, data: dict): + self._data = data + + @property + def data(self) -> dict: + return self._data + + @property + def response(self) -> int: + return int(self._data.get('response')) + + def forwarding(self) -> str: + return self._data.get('forwarding') diff --git a/smspva_wrapper/types/containers/service_price_object.py b/smspva_wrapper/types/containers/service_price_object.py new file mode 100644 index 0000000..655f58d --- /dev/null +++ b/smspva_wrapper/types/containers/service_price_object.py @@ -0,0 +1,29 @@ +from ..countries import Countries, country_dict +from ..services import Services, service_dict + + +class ServicePrice: + """Immutable high level container for get_service_price""" + + def __init__(self, data: dict): + self._data = data + + @property + def data(self) -> dict: + return self._data + + @property + def response(self) -> int: + return int(self._data.get('response')) + + @property + def country(self) -> Countries: + return country_dict.get(self._data.get('country')) + + @property + def service(self) -> Services: + return service_dict.get(self._data.get('service')) + + @property + def price(self) -> float: + return float(self._data.get('price')) diff --git a/smspva_wrapper/types/containers/sms_object.py b/smspva_wrapper/types/containers/sms_object.py new file mode 100644 index 0000000..6d9da05 --- /dev/null +++ b/smspva_wrapper/types/containers/sms_object.py @@ -0,0 +1,21 @@ +class SMS: + """Immutable high level container for get_sms""" + + def __init__(self, data: dict): + self._data = data + + @property + def data(self) -> dict: + return self._data + + @property + def response(self) -> int: + return int(self._data.get('response')) + + @property + def number(self) -> str: + return self._data.get('number') + + @property + def sms(self) -> str: + return self._data.get('sms') diff --git a/smspva_wrapper/types/containers/two_fa_object.py b/smspva_wrapper/types/containers/two_fa_object.py new file mode 100644 index 0000000..7feb990 --- /dev/null +++ b/smspva_wrapper/types/containers/two_fa_object.py @@ -0,0 +1,25 @@ +class TwoFA: + """Immutable high level container for get_two_fa""" + + def __init__(self, data: dict): + self._data = data + + @property + def data(self) -> dict: + return self._data + + @property + def response(self) -> int: + return int(self._data.get('response')) + + @property + def code_two_fa(self) -> str: + return self._data.get('code2fa') + + @property + def secret(self) -> str: + return self._data.get('secret') + + @property + def tonew(self) -> str: + return self._data.get('tonew') diff --git a/smspva_wrapper/types/containers/userinfo_object.py b/smspva_wrapper/types/containers/userinfo_object.py new file mode 100644 index 0000000..50c65e5 --- /dev/null +++ b/smspva_wrapper/types/containers/userinfo_object.py @@ -0,0 +1,25 @@ +class UserInfo: + """Immutable high level container for get_userinfo""" + + def __init__(self, data: dict): + self._data = data + + @property + def data(self) -> dict: + return self._data + + @property + def response(self) -> int: + return int(self._data.get('response')) + + @property + def balance(self) -> float: + return float(self._data.get('balance')) + + @property + def karma(self) -> float: + return float(self._data.get('karma')) + + @property + def name(self) -> str: + return self._data.get('name') diff --git a/smspva_wrapper/types/countries.py b/smspva_wrapper/types/countries.py new file mode 100644 index 0000000..a938b59 --- /dev/null +++ b/smspva_wrapper/types/countries.py @@ -0,0 +1,80 @@ +class Countries: + """Countries as listed on SMSPVA""" + RUSSIAN_FEDERATION = 'RU' # 1 + KAZAKHSTAN = 'KZ' # 2 + UKRAINE = 'UA' # 3 + ROMANIA = 'RO' # 4 + ARGENTINA = 'AR' # 5 + BRAZIL = 'BR' # 6 + CAMBODIA = 'KH' # 7 + COLUMBIA = 'CO' # 8 + CROATIA = 'HR' # 9 + DOMINICANA = 'DO' # 10 + EGYPT_VIRTUAL = 'EG' # 11 + ESTONIA = 'EE' # 12 + FINLAND = 'FI' # 13 + FRANCE = 'FR' # 14 + GEORGIA = 'GE' # 15 + GERMANY = 'DE' # 16 + INDONESIA = 'ID' # 17 + ISRAEL = 'IL' # 18 + KENYA = 'KE' # 29 + KOSOVO = 'XK' # 20 + KYRGYZSTAN = 'KG' # 21 + LAOS = 'LA' # 22 + LATVIA = 'LV' # 23 + LITHUANIA = 'LT' # 24 + MALAYSIA = 'MY' # 25 + MEXICO_VIRTUAL = 'MX' # 26 + NETHERLANDS = 'NL' # 27 + NEW_ZEALAND = 'NZ' # 28 + PARAGUAY = 'PY' # 29 + PHILIPPINES = 'PH' # 30 + POLAND = 'PL' # 31 + PORTUGAL = 'PT' # 32 + SPAIN = 'ES' # 33 + SWEDEN = 'SE' # 34 + UNITED_KINGDOM = 'UK' # 35 + UNITED_STATES = 'US' # 36 + VIETNAM = 'VN' # 37 + + +country_dict = { + 'RU': Countries.RUSSIAN_FEDERATION, # 1 + 'KZ': Countries.KAZAKHSTAN, # 2 + 'UA': Countries.UKRAINE, # 3 + 'RO': Countries.ROMANIA, # 4 + 'AR': Countries.ARGENTINA, # 5 + 'BR': Countries.BRAZIL, # 6 + 'KH': Countries.CAMBODIA, # 7 + 'CO': Countries.COLUMBIA, # 8 + 'HR': Countries.CROATIA, # 9 + 'DO': Countries.DOMINICANA, # 10 + 'EG': Countries.EGYPT_VIRTUAL, # 11 + 'EE': Countries.ESTONIA, # 12 + 'FI': Countries.FINLAND, # 13 + 'FR': Countries.FRANCE, # 14 + 'GE': Countries.GEORGIA, # 15 + 'DE': Countries.GERMANY, # 16 + 'ID': Countries.INDONESIA, # 17 + 'IL': Countries.ISRAEL, # 18 + 'KE': Countries.KENYA, # 19 + 'XK': Countries.KOSOVO, # 20 + 'KG': Countries.KYRGYZSTAN, # 21 + 'LA': Countries.LAOS, # 22 + 'LV': Countries.LATVIA, # 23 + 'LT': Countries.LITHUANIA, # 24 + 'MY': Countries.MALAYSIA, # 25 + 'MX': Countries.MEXICO_VIRTUAL, # 26 + 'NL': Countries.NETHERLANDS, # 27 + 'NZ': Countries.NEW_ZEALAND, # 28 + 'PY': Countries.PARAGUAY, # 29 + 'PH': Countries.PHILIPPINES, # 30 + 'PL': Countries.POLAND, # 31 + 'PT': Countries.PORTUGAL, # 32 + 'ES': Countries.SPAIN, # 33 + 'SE': Countries.SWEDEN, # 34 + 'UK': Countries.UNITED_KINGDOM, # 35 + 'US': Countries.UNITED_STATES, # 36 + 'VN': Countries.VIETNAM # 37 +} diff --git a/smspva_wrapper/types/operators.py b/smspva_wrapper/types/operators.py new file mode 100644 index 0000000..5749cad --- /dev/null +++ b/smspva_wrapper/types/operators.py @@ -0,0 +1,11 @@ +class Operators: + BEELINE_RU = 'Beeline_RU' + MTS_RU = 'MTS_RU' + MEGAFON_RU = 'Megafon_RU' + BEELINE_KZ = 'Beeline_KZ' + TELE2_KZ = 'Tele2_KZ' + ACTIV_KZ = 'Activ_KZ' + ALTEL_KZ = 'Altel_KZ' + LIFECELL_US = 'Lifecell_UA' + KYIVSTAR_UA = 'Kyivstar_UA' + VODAFONE_UA = 'Vodafone_UA' diff --git a/smspva_wrapper/types/services.py b/smspva_wrapper/types/services.py new file mode 100644 index 0000000..f280c23 --- /dev/null +++ b/smspva_wrapper/types/services.py @@ -0,0 +1,224 @@ +class Services: + """Services as listed on SMSPVA""" + ONE_SIX_EIGHT_EIGHT_COM = 'opt28' + ADIDAS_NIKE = 'opt86' + AIRBNB = 'opt46' + ALIBABA_TAOBAO = 'opt61' + AMAZON = 'opt44' + AMAZON_CALL = 'opt901' + AOL = 'opt10' + AUTO_RU = 'opt38' + AVITO = 'opt59' + BADOO = 'opt56' + BAND_US = 'opt118' + BETFAIR = 'opt25' + BOLT = 'opt81' + BURKERKING = 'opt3' + CAREEM = 'opt89' + CDKEYS_COM = 'opt39' + CITYMOBIL = 'opt76' + COINBASE = 'opt112' + CONTACT = 'opt51' + CRAIGSLIST = 'opt26' + DENT = 'opt99' + DIDI = 'opt92' + DISCORD = 'opt45' + DODOPIZZA_PAPAJOHNS = 'opt27' + DOORDASH = 'opt40' + DROM_RU = 'opt32' + DRUG_VOKRUG = 'opt31' + EASYPAY = 'opt21' + FACEBOOK = 'opt2' + FASTMAIL = 'opt43' + FIVERR = 'opt6' + FOTOSTRATA = 'opt13' + FULLCONTACT = 'opt78' + G2A_COM = 'opt68' + GAMEFLIP = 'opt77' + GETTAXI = 'opt35' + GLOVO_RAKETA = 'opt108' + GOOGLE = 'opt1' + GRABTAXI = 'opt30' + GRAILED = 'opt9001' + GRINDR = 'opt110' + ICARD = 'opt103' + INSTAGRAM = 'opt16' + JD_COM = 'opt94' + KAKAOTALK = 'opt71' + LAZADA = 'opt60' + LINE_MESSENGER = 'opt37' + LINKED_IN = 'opt8' + LIVESCORE = 'opt42' + LOCALBITCOINS = 'opt105' + LOCANTO_COM = 'opt114' + LYFT = 'opt75' + MAIL_RU = 'opt33' + MAIL_RU_GROUP = 'opt4' + MAMBA = 'opt100' + MEETME = 'opt17' + MICHAT = 'opt96' + MONEYRAWR = 'opt22' + MRSPEEDY = 'opt47' + MS_OFFICE_365 = 'opt7' + HOTMAIL = 'opt15' + MTS_CASHBACK = 'opt48' + NAVER = 'opt73' + NETTELLER = 'opt116' + NETFLIX = 'opt101' + OD = 'opt5' + OFFERUP = 'opt113' + OLACABS = 'opt95' + OLX_GOODS_RU = 'opt70' + ONREALT_RU = 'opt0' + ORACLE_CLOUD = 'opt115' + OTHER = 'opt19' + PADDY_POWER = 'opt109' + PAYPAL_EBAY = 'opt83' + POF_COM = 'opt84' + PROM_UA = 'opt107' + PROTONMAIL = 'opt57' + RAMBLER = 'opt53' + RSA = 'opt111' + SAICMOBILITY = 'opt82' + SKOUT = 'opt49' + SKRILL = 'opt117' + SNAPCHAT = 'opt90' + STEAM = 'opt58' + STREETBEES = 'opt98' + SUOMI24 = 'opt91' + TAN_MICROPAYMENT = 'opt55' + TAXI_MAKSIM = 'opt74' + TELEGRAM = 'opt29' + TENCENT_QQ = 'opt34' + THE_INSIDERS = 'opt14' + TICKETMASTER = 'opt52' + TIKTOK = 'opt104' + TINDER = 'opt9' + TWILIO = 'opt66' + TWITTER = 'opt41' + UBER = 'opt72' + VENMO = 'opt85' + VIBER = 'opt11' + VK = 'opt69' + WEBMONEY_ENUM = 'opt24' + WECHAT = 'opt67' + WEEBLY = 'opt54' + LASTPASS = 'opt80' + WHATSAPP = 'opt20' + YAHOO = 'opt65' + YALLA_LIVE = 'opt88' + YANDEX = 'opt23' + ZOHO = 'opt93' + QIWI = 'opt18' + WEEBLY_TWO = 'opt901' + VK_TWO = 'opt69' + + +service_dict = { + 'opt28': Services.ONE_SIX_EIGHT_EIGHT_COM, + 'opt86': Services.ADIDAS_NIKE, + 'opt46': Services.AIRBNB, + 'opt61': Services.ALIBABA_TAOBAO, + 'opt44': Services.AMAZON, + 'opt10': Services.AOL, + 'opt38': Services.AUTO_RU, + 'opt56': Services.BADOO, + 'opt118': Services.BAND_US, + 'opt25': Services.BETFAIR, + 'opt81': Services.BOLT, + 'opt3': Services.BURKERKING, + 'opt89': Services.CAREEM, + 'opt39': Services.CDKEYS_COM, + 'opt76': Services.CITYMOBIL, + 'opt112': Services.COINBASE, + 'opt51': Services.CONTACT, + 'opt26': Services.CRAIGSLIST, + 'opt99': Services.DENT, + 'opt92': Services.DIDI, + 'opt45': Services.DISCORD, + 'opt27': Services.DODOPIZZA_PAPAJOHNS, + 'opt40': Services.DOORDASH, + 'opt32': Services.DROM_RU, + 'opt21': Services.EASYPAY, + 'opt2': Services.FACEBOOK, + 'opt43': Services.FASTMAIL, + 'opt6': Services.FIVERR, + 'opt78': Services.FULLCONTACT, + 'opt68': Services.G2A_COM, + 'opt77': Services.GAMEFLIP, + 'opt35': Services.GETTAXI, + 'opt108': Services.GLOVO_RAKETA, + 'opt1': Services.GOOGLE, + 'opt30': Services.GRABTAXI, + 'opt9001': Services.GRAILED, + 'opt110': Services.GRINDR, + 'opt103': Services.ICARD, + 'opt16': Services.INSTAGRAM, + 'opt94': Services.JD_COM, + 'opt71': Services.KAKAOTALK, + 'opt80': Services.LASTPASS, + 'opt60': Services.LAZADA, + 'opt37': Services.LINE_MESSENGER, + 'opt8': Services.LINKED_IN, + 'opt42': Services.LIVESCORE, + 'opt105': Services.LOCALBITCOINS, + 'opt114': Services.LOCANTO_COM, + 'opt75': Services.LYFT, + 'opt33': Services.MAIL_RU, + 'opt4': Services.MAIL_RU_GROUP, + 'opt100': Services.MAMBA, + 'opt17': Services.MEETME, + 'opt96': Services.MICHAT, + 'opt15': Services.HOTMAIL, + 'opt7': Services.MS_OFFICE_365, + 'opt22': Services.MONEYRAWR, + 'opt47': Services.MRSPEEDY, + 'opt48': Services.MTS_CASHBACK, + 'opt73': Services.NAVER, + 'opt116': Services.NETTELLER, + 'opt101': Services.NETFLIX, + 'opt113': Services.OFFERUP, + 'opt95': Services.OLACABS, + 'opt70': Services.OLX_GOODS_RU, + 'opt0': Services.ONREALT_RU, + 'opt115': Services.ORACLE_CLOUD, + 'opt109': Services.PADDY_POWER, + 'opt83': Services.PAYPAL_EBAY, + 'opt84': Services.POF_COM, + 'opt107': Services.PROM_UA, + 'opt57': Services.PROTONMAIL, + 'opt18': Services.QIWI, + 'opt53': Services.RAMBLER, + 'opt82': Services.SAICMOBILITY, + 'opt117': Services.SKRILL, + 'opt90': Services.SNAPCHAT, + 'opt58': Services.STEAM, + 'opt98': Services.STREETBEES, + 'opt91': Services.SUOMI24, + 'opt55': Services.TAN_MICROPAYMENT, + 'opt29': Services.TELEGRAM, + 'opt34': Services.TENCENT_QQ, + 'opt52': Services.TICKETMASTER, + 'opt104': Services.TIKTOK, + 'opt9': Services.TINDER, + 'opt66': Services.TWILIO, + 'opt41': Services.TWITTER, + 'opt72': Services.UBER, + 'opt85': Services.VENMO, + 'opt11': Services.VIBER, + 'opt24': Services.WEBMONEY_ENUM, + 'opt67': Services.WECHAT, + 'opt54': Services.WEEBLY, + 'opt901': Services.WEEBLY_TWO, + 'opt20': Services.WHATSAPP, + 'opt65': Services.YAHOO, + 'opt88': Services.YALLA_LIVE, + 'opt93': Services.ZOHO, + 'opt59': Services.AVITO, + 'opt69': Services.VK_TWO, + 'opt31': Services.DRUG_VOKRUG, + 'opt74': Services.TAXI_MAKSIM, + 'opt13': Services.FOTOSTRATA, + 'opt14': Services.THE_INSIDERS, + 'opt23': Services.YANDEX +}