def insertAlias(self, alias='', idemail=1):
Error.executing(f"Guardando alias {alias} en base de datos",
self.listerrorExecutinModulo)
if not str(idemail).isdigit():
idemail = self.getIdEmail(idemail)
if not idemail:
Error.warn(
f"No es posible insertar el alias {alias} en la base de datos, El ID del email es incorrecto"
)
return False
try:
self.cursor.execute(
f"INSERT INTO alias(alias,idemail) VALUES('{alias}','{idemail}')"
)
except Exception as e:
Error.e(
1,
f"No fue posible insertar alias [{alias}] a la base de datos")
Error.warn(e)
return False
else:
self.db.commit()
Error.executing(f"[{alias}] se insertó correctamente",
self.listerrorExecutinModulo)
return self.cursor.lastrowid
def __init__(self):
##os.system('clear')
Error.info("Configurando Instagram para su uso")
self.proxy = RandomProxy()
urlproxy = self.proxy.get()
self.session = requests.Session()
Error.executing("Configurando proxy", self.listerrorExecutinModulo)
def emailIsTaken(self):
Error.executing(f"el correo {self.email} alparecer esta en uso.",
self.listerrorExecutinModulo)
self.email = tm.getEmailLogin(True)
Error.executing(
f"Se actualizo a: {Fore.RED}{self.email}{Style.RESET_ALL}",
self.listerrorExecutinModulo)
return self.email
def deleteAllEmails(self):
Error.executing(
f"{Fore.RED}Eliminando todos los emails de{Style.RESET_ALL} {Fore.YELLOW}{self.mail}{Style.RESET_ALL}",
self.listerrorExecutinModulo)
mails = self.getInboxMail()
if len(mails) != 0:
for mail in mails:
self.deleteEmail(mail['mail_id'])
def setNewEmail(self):
Error.executing(f"el correo {self.email} alparecer esta en uso.",
self.listerrorExecutinModulo)
from src.new_tempmail import TempMail
self.email = tm.getEmailLogin(True)
Error.executing(
f"Se actualizo a: {Fore.RED}{self.email}{Style.RESET_ALL}",
self.listerrorExecutinModulo)
return self.email
def __init__(self, table=None):
if self.db == None:
Error.e(1, "ERROR FATAL: No db select")
else:
if table == None:
Error.e(1, "ERROR FATAL: No table select")
else:
self.Where.db = self.db
self.Where.delete = "DELETE FROM {} WHERE ".format(table)
def checkHasAlias(self, email):
Error.executing(f"Verificando si {email} tiene Alias",
self.listerrorExecutinModulo)
self.cursor.execute(
f"SELECT count(a.id) FROM alias a INNER JOIN emails e ON e.id=a.idemail WHERE (e.email='{str(email)}' OR e.id='{str(email)}')"
)
if self.cursor.fetchone()[0] > 0:
return True
else:
return False
def __init__(self, email='', password=''):
Error.info("Configurando Hushmail para su uso")
if not email.strip():
Error.e(1, "No se pudo configurar una cuenta de correo")
Error.warn("Saliendo del script")
sys.exit("Saliendo del script")
if not password.strip():
Error.e(1, "No se pudo configurar una clave de paso")
Error.warn("Saliendo del script")
self.email = email
self.password = password
def __init__(self, table, arr=[]):
Error.executing("Parseando Array en SET",
Sql.listerrorExecutinModulo)
f = ''
i = 1
for column, value in arr:
f += f"UPDATE {table} SET {column}='{value}'"
if i != len(arr):
f += ', '
i += 1
self.Where.update = f
def checkAliasEmail(self, alias, email):
Error.executing(f"Verificando Alias: {alias} para Email: {email}",
self.listerrorExecutinModulo)
self.cursor.execute(
f"SELECT a.id FROM alias a INNER JOIN emails e ON e.id=a.idemail WHERE a.alias like '%{str(alias)}%' AND (e.email='{str(email)}' OR e.id='{str(email)}')"
)
idalias = self.cursor.fetchone()
if idalias == None:
return False
else:
return idalias[0]
def waitrefresh(self):
Error.executing(f"Muchas peticiones, Se detecto como DDOS",
self.listerrorExecutinModulo)
for i in tqdm(range(self.waitTimeRange)):
time.sleep(0.2)
if self.waitTimeRange >= 400:
self.changeProxy()
if self.waitTimeRange >= 800:
self.waitTimeRange = 100
self.waitTimeRange *= 2
self.postCreateAccount()
def __init__(self,
login=None,
domain=None,
api_domain="api4.temp-mail.org"):
Error.info("Iniciando configuracoin de TempMail")
self.login = login
self.domain = domain
self.api_domain = api_domain
Error.executing("Buscando domains validos para tempmail",
self.listerrorExecutinModulo)
url = f"https://{self.api_domain}/request/domains/format/json/"
r = requests.get(url)
self.domains = r.json()
def getIdEmail(self, email=''):
if not email.strip():
Error.e(1, "No es posible buscar id a un email vacio")
return False
else:
Error.executing(f"Buscando ID de {email}",
self.listerrorExecutinModulo)
self.cursor.execute(
f"SELECT id FROM emails WHERE email='{str(email)}' ")
resp = self.cursor.fetchone()
if resp == None:
return False
else:
return resp[0]
def generateFromJson(self, number=10, file=''):
if not file.strip():
file = self.path + '/libs/nombres.json'
Error.executing(f"Archivo {file} por defecto",
self.sru_listerrorExecutinModulo)
if os.path.isfile(file):
Error.executing("Cargando archivo de nombres...",
self.sru_listerrorExecutinModulo)
with open(file, 'r') as json_file:
nombres = json.loads(json_file.read())
self.Nombres.append(nombres)
Error.executing(f"Generando nombres...",
self.sru_listerrorExecutinModulo)
for nombre in range(number):
select = random.sample(nombres, 2)
randomNumber = random.randrange(10, 99)
randomLetters = ''.join(
random.choice(string.ascii_lowercase)
for i in range(3))
username = "******".join(select) + str(
randomNumber) + randomLetters
fname = select[0]
lname = select[1]
fullname = " ".join(select)
password = hashlib.md5(
str(str(time.time()) +
username).encode('utf-8')).hexdigest()
self.Users.append({
"fname": fname,
"lname": lname,
"fullname": fullname,
"username": username.lower(),
"password": password,
"country": "CO",
"age": random.randrange(18, 50)
})
Error.executing(
f"Informacion de cuentas generada: #{len(self.Users)} habilitados.",
self.sru_listerrorExecutinModulo)
return self.Users
else:
Error.e(1, f"FILE {file} NO EXISTE")
pass
def createInstagramAccont(self, **columns):
sql = "INSERT INTO instagram"
sql += "("
values = " VALUES ("
i = 1
for column in columns:
if i == len(columns):
sql += "{})".format(str(column))
values += "'{}')".format(str(columns[column]))
else:
sql += "{},".format(str(column))
values += "'{}',".format(str(columns[column]))
i += 1
try:
self.cursor.execute(sql + values)
except Exception as e:
Error.e(
1,
f"No fue posible insertar la cuenta de instagram en la base de datos"
)
Error.warn(e)
return False
else:
self.db.commit()
Error.ok(f"EXITO: Cuenta de instagram se agrego correctamente.")
return self.cursor.lastrowid
def __init__(self, arr=[], logical='AND', operador='='):
if self.update == None:
Error.e(1, "No es psible actualizar base de datos")
else:
Error.executing("Parseando Array en WHERE",
Sql.listerrorExecutinModulo)
w = ' WHERE '
i = 1
for column, value in arr:
w += f'{column}{operador}{str(value)}'
if i != len(arr):
w += logical
i += 1
self.update += w
self.db.query(self.update)
self.db.db.commit()
numwrro = self.db.cursor.rowcount
if numwrro > 1:
Error.info(f"Se actualizaron {numwrro} tablas")
elif numwrro == 1:
Error.info(f"Se actualizo {numwrro} tabla")
else:
Error.warn("No se actualizo la base de datos")
def changeProxy(self):
self.listerrorExecutinModulo = "INSTAGRAM"
Error.executing("Cambiando proxy para esta Session",
self.listerrorExecutinModulo)
self.urlproxy = self.proxy.get()
Error.info(f"Probando conexion del proxy: {self.urlproxy}")
self.session.proxies = {
"http": "{}".format(self.urlproxy),
"https": "{}".format(self.urlproxy),
}
try:
r = self.session.get("https://api.ipify.org/")
except Exception as e:
Error.e(1, "PROXY NO CONNECT")
self.changeProxy()
return False
else:
self.listerrorExecutinModulo = f"INSTAGRAM {Fore.RED}{r.text}{Style.RESET_ALL} "
Error.executing(f"Ahora el proxy {self.urlproxy} esta en uso",
self.listerrorExecutinModulo)
return self.urlproxy
def __init__(self,
host=Config["mysql"]["host"],
user=Config["mysql"]["user"],
password=Config["mysql"]["pass"],
database=Config["mysql"]["db"]):
Error.info(f"Creando Conexion a base de datos MYSQL [{host}]")
try:
self.db = MySQLdb.connect(host, user, password, database)
except Exception as e:
Error.e(1, e)
Error.e(
1,
"Es necesaria una conexion a una base de datos para poder continuar"
)
sys.exit()
else:
Error.executing(
f"Conexion a MYSQL establecida como User:[{user}], DB:[{database}]",
self.listerrorExecutinModulo)
self.cursor = self.db.cursor()
self.Update.Where.db = self
self.Delete.db = self
self.Select.db = self
def __init__(self, arr=[], logical="AND", operador='='):
if self.delete == None:
Error.e(1, "No es posible ejecutar la query")
else:
Error.executing("Parseando Array en WHERE",
Sql.listerrorExecutinModulo)
w = ''
i = 1
for column, value in arr:
w += f'{column}{operador}{value}'
if i != len(arr):
w += logical
i += 1
self.delete += w
self.db.query(self.delete)
self.db.db.commit()
numwrro = self.db.cursor.rowcount
Error.warn(f"{numwrro} record(s) deleted")
def __new__(self):
qr = f'{self._self._select}{self._self._from}{self._self._inner}{self._self._where}{self._self._order}{self._self._group}{self._self._limit}'
Error.executing(qr, self._self.db.listerrorExecutinModulo)
try:
resp = list(self._self.db.fetchAll(qr))
except Exception as e:
Error.e(1, "ERROR AL EJECUTAR QUERY")
Error.warn(e)
return []
else:
resp_new = []
field_name = [
field[0]
for field in self._self.db.cursor.description
]
for row in resp:
row_new = zip(field_name, row)
resp_new.append(dict(row_new))
return resp_new
def createAccount(self, **kw):
self.setVariablesCreate(**kw)
self.initialConnect()
self.postCreateAccount()
Error.e(1, "FIN DE CODIGO")
return True
def __init__(self):
Error.executing("Iniciando la creacion de nombres aleatorios",
self.sru_listerrorExecutinModulo)
self.path = sys.path[0]
self.username = "******"
def getInboxMail(self):
# https://api4.temp-mail.org/request/mail/id/b867f1fd7346280901b19da061fdc90e/format/json
Error.executing(
f"Verificando inbox de:{Fore.YELLOW}{self.mail}{Style.RESET_ALL}",
self.listerrorExecutinModulo)
if self.mailid is None:
Error.executing(
"No se ha encontrado un HASH de email, procediendo a generar cuenta",
self.listerrorExecutinModulo)
self.getEmailLogin(True)
url = f"https://{self.api_domain}/request/mail/id/{self.mailid}/format/json"
try:
r = requests.get(url)
except Exception as e:
Error.e(
1,
f"No es posible hacer la conexion a {self.listerrorExecutinModulo}"
)
Error.warn(e)
if self.errorReconect > self.errorMaxReconect:
self.errorReconect = 0
Error.e(1, f"No es posible mostrar lista de correo")
return False
else:
self.errorReconect += 1
Error.info("Intentando reconectar".center(50, '.'))
self.getInboxMail(idemail)
else:
mails = r.json()
if 'error' in mails:
Error.info(
f"La cuenta de correo {Fore.YELLOW}{self.mail}{Style.RESET_ALL} no tiene emails en INBOX"
)
mails = []
else:
for mail in mails:
mail.pop("mail_html")
mail.pop("mail_text_only")
return mails
def getEmailLogin(self, setnew=False):
if setnew:
if self.login is None:
Error.executing(f"Generando una cuenta de email nueva",
self.listerrorExecutinModulo)
if len(self.Users) == 0:
self.generate(1)
self.login = self.Users[0]['username']
if self.domain is None:
Error.executing("Buscando domains validos para tempmail",
self.listerrorExecutinModulo)
url = f"https://{self.api_domain}/request/domains/format/json/"
try:
r = requests.get(url)
except Exception as e:
Error.e(
1,
f"No es posible hacer la conexion a {self.listerrorExecutinModulo}"
)
Error.warn(e)
if self.errorReconect > self.errorMaxReconect:
self.errorReconect = 0
Error.e(1, f"No es posible mostrar lista de correo")
return False
else:
self.errorReconect += 1
Error.info("Intentando reconectar".center(50, '.'))
self.getEmailLogin(setnew)
else:
self.domains = r.json()
self.domain = random.choice(self.domains)
self.mail = "{}{}".format(self.login, self.domain)
self.mailid = self.getHash()
else:
if self.login is None:
n = self.generate(1)
Error.executing("Selecionando username para el email",
self.listerrorExecutinModulo)
self.login = n[0]['username']
if self.domain is None:
Error.executing("Selecionando dominio de email",
self.listerrorExecutinModulo)
self.domain = random.choice(self.domains)
mail = "{}{}".format(self.login, self.domain)
if self.mail is None:
self.mail = mail
Error.executing(
f"Generando HASH del email: {Fore.YELLOW}{self.mail}{Style.RESET_ALL}",
self.listerrorExecutinModulo)
self.mailid = md5(self.mail.encode('utf-8')).hexdigest()
return self.mail
def deleteEmail(self, idemail):
Error.executing(
f"Eliminando email de {Fore.YELLOW}{self.mail}{Style.RESET_ALL} con id:{idemail}",
self.listerrorExecutinModulo)
url = f"https://{self.api_domain}/request/delete/id/{idemail}/format/json"
try:
r = requests.get(url)
except Exception as e:
Error.e(
1,
f"No es posible hacer la conexion a {self.listerrorExecutinModulo}"
)
Error.warn(e)
if self.errorReconect > self.errorMaxReconect:
self.errorReconect = 0
Error.e(1, f"No es posible eliminar el email:{idemail}")
else:
self.errorReconect += 1
Error.info("Intentando reconectar".center(50, '.'))
self.deleteEmail(idemail)
else:
rj = r.json()
if rj["result"] == "success":
Error.ok(f"Se elimino el email:{idemail} con exito")
pass
def createAlias(self, form_token='', alias='', savealias=False):
Error.info(f"Iniciando creacion de alias...")
if not alias.strip():
Error.warn(f"No es posible crear el alias '{alias}'")
else:
Error.executing("Accediendo a alias de hushmail",
self.listerrorExecutinModulo)
try:
requestsAlias = self.session.get(self.loginUrlAlias)
except Exception as e:
Error.e(1, "No es posible hacer la conexion a Hushmail")
Error.warn(e)
if self.errorReconect > 5:
self.errorReconect = 0
return False
else:
self.errorReconect += 1
Error.info("Intentando reconectar".center(50, '.'))
self.createAlias(form_token=form_token, alias=alias)
else:
Error.executing("Verificando form_token",
self.listerrorExecutinModulo)
if not form_token.strip():
htmlAlias = BeautifulSoup(
requestsAlias.json()['content'][0]['elements'][0]
['html'], 'html.parser')
formAlias = htmlAlias.find(
"form", {"name": "editPseudonymsForm_new"})
self.aliasExtencion = formAlias.find(
"span", {
"class": "secondary"
}).text
AliasToken = formAlias.find(
"input", {"name": "form_token"})['value']
else:
AliasToken = form_token
form_token = AliasToken
self.session.headers.update({
"Connection":
"keep-alive",
"Content-Type":
"application/x-www-form-urlencoded; charset=UTF-8",
"X-Hush-Ajax-Start-Time":
f"{int(time.time()*1000)}",
"X-Hush-Generated-Password-Method":
"Store",
"X-Requested-With":
"XMLHttpRequest",
})
formDataAlias = {
"form_token": form_token,
"__hushform_extra_fields": "",
"alias": str(alias),
"current_alias": "",
"save": "Save",
"processAjax": "editPseudonymsForm"
}
Error.executing(f"Creando Alias {alias}",
self.listerrorExecutinModulo)
try:
requestsCreateAlias = self.session.post(
self.urlCreateAlias,
data=formDataAlias,
allow_redirects=True)
except Exception as e:
Error.e(1, "No es posible hacer la conexion a Hushmail")
Error.warn(e)
Error.info("Intentando reconectar".center(50, '.'))
if self.errorReconect > 5:
self.errorReconect = 0
return False
else:
self.errorReconect += 1
Error.info("Intentando reconectar".center(50, '.'))
self.createAlias(form_token=form_token, alias=alias)
else:
responseCreateAlias = requestsCreateAlias.json()
if responseCreateAlias['formValidation']:
if savealias:
sql = Sql()
idalias = ql.insertAlias(
f"{alias}{self.aliasExtencion}", self.email)
if not idalias:
return False
else:
return idalias
return True
else:
return False
def login(self):
Error.info(f"Iniciando session en Hushmail como [{self.email}]")
self.session = requests.Session()
try:
session_start = self.session.get(self.loginUrlGet)
except Exception as e:
Error.e(1, "No es posible hacer la conexion a Hushmail")
Error.warn(e)
if self.errorReconect > 5:
self.errorReconect = 0
Error.e(1, "SALIENDO DEL SCRIPT".center(50, '.'))
sys.exit()
else:
self.errorReconect += 1
Error.info("Intentando reconectar".center(50, '.'))
self.login()
else:
Error.executing("Recopilando Headers & Cookies",
self.listerrorExecutinModulo)
soup = BeautifulSoup(session_start.text, 'html.parser')
Error.executing("Parseando resultado",
self.listerrorExecutinModulo)
form_token = soup.find('input', {'name': 'form_token'})['value']
Error.executing("Obteniendo form_token para el login",
self.listerrorExecutinModulo)
Error.executing("Aplicando nuevos Headers",
self.listerrorExecutinModulo)
self.session.headers.update({
"Accept":
"application/json, text/javascript, */*; q=0.01",
"Accept-Encoding":
"gzip, deflate, br",
"DNT":
"1",
"Host":
"secure.hushmail.com",
"Origin":
"https://secure.hushmail.com",
# "Referer":"https://secure.hushmail.com/preview/hushmail/",
"Referer":
self.loginUrlGet,
"Content-Type":
"application/x-www-form-urlencoded; charset=UTF-8",
"X-Hush-Ajax-Start-Time":
str(int(time.time() * 1000)),
"X-Requested-With":
"XMLHttpRequest"
})
Error.executing("Construyendo url-encode para el formulario",
self.listerrorExecutinModulo)
dataPost = {
"form_token": form_token,
# "form_token":"e1ceed8e70107ef3ee6adb69e3d2cd39_546b90918696",
"__hushform_extra_fields": "",
"next_webapp_page": "",
"hush_domain": "hushmail.com",
"hush_username": self.email,
# "hush_username":"******",
"hush_passphrase": self.password,
# "hush_passphrase":"edens.123.321",
"hush_remember_me": "",
"hush_authcode": "",
"hush_authenticated": "",
"hush_customerid": "0000000000000000",
"processAjax": "authenticationform",
"formPage": "loginpage",
}
try:
create_request = self.session.post(self.loginUrlPost,
data=dataPost,
allow_redirects=True)
except Exception as e:
Error.e(1, "No es posible hacer la conexion a Hushmail")
if self.errorReconect > 5:
self.errorReconect = 0
Error.e(1, "SALIENDO DEL SCRIPT".center(50, '.'))
sys.exit()
else:
self.errorReconect += 1
Error.info("Intentando reconectar".center(50, '.'))
self.login()
else:
response = create_request.json()
if response['formValidation']:
Error.ok(f"{self.email} Ha iniciado session correctamente")
else:
Error.e(
1,
f"No fue posible crear la session como [{self.email}]")
ppjson(response)
def initialConnect(self):
self.changeProxy()
Error.executing(f"Estableciendo conexion inicial",
self.listerrorExecutinModulo)
try:
resp = requests.get(self.webCreateUrlSharedData)
except requests.exceptions.ProxyError as err:
Error.warn("Reconectando".center(widthCenter, '-'))
Error.e(1, err)
self.initialConnect()
except requests.exceptions.SSLError as err:
Error.warn("Reconectando".center(widthCenter, '-'))
Error.e(1, err)
self.initialConnect()
except Exception as e:
Error.e(
1,
f"No es posible hacer la conexion a {self.listerrorExecutinModulo}"
)
Error.warn(e)
if self.errorReconect > self.errorMaxReconect:
self.errorReconect = 0
self.initialConnect()
else:
self.errorReconect += 1
Error.info("Intentando reconectar".center(widthCenter, '.'))
self.initialConnect()
else:
rjson = resp.json()
self.csrftoken = rjson['config']['csrf_token']
self.xInstagramAJAX = rjson['rollout_hash']
self.AcceptLanguage = rjson['language_code']
self.deviceId = rjson['device_id']
self.public_key = rjson['encryption']['public_key']
self.key_id = rjson['encryption']['key_id']
return rjson
return False
def setVariablesCreate(self, **kw):
Error.executing("Definiendo variables...",
self.listerrorExecutinModulo)
for item in kw:
setattr(self, item, kw[item])
return False
def crearcuenta(self, **kw):
self.initialConnect()
self.setVariablesCreate(**kw)
formData = {
'email': self.email,
'password': self.password,
'username': self.username,
'first_name': self.nombre,
'seamless_login_enabled': '1',
'tos_version': 'row',
'opt_into_one_tap': 'false'
}
s = requests.Session()
s.headers.update({
"Accept-Language":
self.AcceptLanguage,
"Content-Type":
"application/x-www-form-urlencoded",
"X-CSRFToken":
self.csrftoken,
"X-IG-App-ID":
"936619743392459",
"X-IG-WWW-Claim":
"0",
"X-Instagram-AJAX":
self.xInstagramAJAX,
"X-Requested-With":
"XMLHttpRequest",
"Host":
"www.instagram.com",
"Origin":
"https://www.instagram.com",
"Referer":
"https://www.instagram.com/",
"User-Agent":
"Mozilla/5.0 (X11; Linux x86_64; rv:73.0) Gecko/20100101 Firefox/73.0",
})
s.cookies.update({
"csrftoken": self.csrftoken,
"ig_did": self.deviceId,
})
s.proxies = {
"http": "{}".format(self.urlproxy),
"https": "{}".format(self.urlproxy),
}
resp_ip = s.get("https://api.ipify.org/")
Error.warn("".center(widthCenter, '.'))
Error.warn(resp_ip.text.center(widthCenter, '.'))
Error.warn("".center(widthCenter, '.'))
Error.executing(f"Creando cuenta...", self.listerrorExecutinModulo)
Error.info(
f"{'Username:'******'~')} {'Email: '+self.email.center(50,'~')}"
)
try:
resp = s.post(self.webCreateUrl,
data=formData,
allow_redirects=True)
except Exception as e:
Error.info("Intentando reconectar con instagram".center(50, '.'))
self.crearcuenta(**kw)
else:
Error.info(f"Status Code: {resp.status_code}".center(
widthCenter, '.'))
if resp.status_code == 200:
rjson = resp.json()
if 'errors' in rjson:
errorType = rjson['error_type']
Error.e(
1,
f"Se encontraron errores al crear la cuenta de instagram, error type: {Fore.RED}{errorType}{Style.RESET_ALL}"
)
for error in rjson['errors']:
Error.warn(f"Error en: [{error}]")
if error in ["error", "ip"]:
for item in rjson['errors'][error]:
Error.e(
1,
f"{self.listerrorExecutinModulo} [{error}]: {item}"
)
Error.executing(f"Intentando crear nuevamente",
self.listerrorExecutinModulo)
self.crearcuenta(**kw)
else:
for item in rjson['errors'][error]:
message = item['message']
code = item['code']
Error.e(
1,
f"[{Fore.RED}{code}{Style.RESET_ALL}]: {message}"
)
sys.exit()
else:
Error.ok("".center(widthCenter, '-'))
Error.ok(
"EXITO: Cuenta creada, Email:{} username:{} password: {}"
.format(self.email, self.username, self.password))
self.guardarcuentacreada()
Error.ok("".center(widthCenter, '-'))
sys.exit()
elif resp.status_code == 429:
Error.executing(f"Muchas peticiones, Se detecto como DDOS",
self.listerrorExecutinModulo)
sys.exit()
elif resp.status_code == 400:
Error.ok("".center(widthCenter, '-'))
Error.ok(
"EXITO: Cuenta creada, Email:{} username:{} password: {}".
format(self.email, self.username, self.password))
self.guardarcuentacreada()
Error.ok("".center(widthCenter, '-'))
sys.exit()
pass
else:
Error.warn(resp.text)
sys.exit()
