def genMegaAccount(numAccounts=1):
for i in range(numAccounts):
session = GuerrillaMailSession()
password = ''.join(random.SystemRandom().choice(string.ascii_uppercase + string.digits) for _ in range(10))
pre_email_count = len(session.get_email_list())
verify_link = subprocess.check_output(
["megatools", "reg", "-n", names.get_full_name(), "-e", session.email_address, "-p", password, "--register",
"--scripted"]).decode("utf-8").replace("@LINK@\n", "{}")
while pre_email_count == len(session.get_email_list()): sleep(1)
verify_command = (verify_link.format(
html.fromstring(session.get_email(session.get_email_list()[0].guid).body).xpath(
"//a[contains(@href, 'confirm')]/@href")[0])).split()
if "successfull" in subprocess.check_output(verify_command).decode("utf-8"):
print(":".join([session.email_address, password]))
def get(seq):
SS = ss.SS("Yaspin")
SS.status = 0
if (len(seq) > 4000):
SS.pred += "Sequence longer than 4000"
SS.conf += "Sequence longer than 4000"
SS.status = 2 #error status
print("YASPIN failed: Sequence longer than 4000")
return SS #return SS so it will be readable as an ssObject
session = GuerrillaMailSession() #Creates GuerrillaMail session
email_address = session.get_session_state()[
'email_address'] #retrieves temp email address
payload = {
'seq': seq,
'mbjob[description]': 'testprot',
'nnmethod': 'dssp',
'smethod': 'nr',
'yaspin_align': 'YASPIN prediction',
'email': email_address
}
fasta = {'seq_file': ''}
r = requests.post('http://www.ibi.vu.nl/programs/yaspinwww/',
data=payload,
files=fasta)
if (r.status_code == 500):
SS.pred += "Server Down"
SS.conf += "Server Down"
SS.status = 2
print("Yaspin Failed: Server Down")
return SS
result_url = r.url + 'results.out'
requesturl = batchtools.requestWait(result_url, 'Yaspin Not Ready')
if requesturl:
raw = requesturl.text.splitlines()
for i in range(len(raw)):
if raw[i].startswith(" Pred:"):
SS.pred += raw[i][6:].strip()
if raw[i].startswith(" Conf:"):
SS.conf += raw[i][6:].strip()
SS.pred = SS.pred.replace('-', 'C')
SS.status = 1
print("Yaspin Complete")
else:
SS.pred += "Yaspin failed to respond in time"
SS.conf += "Yaspin failed to respond in time"
SS.status = 2 #error status
print("YASPIN failed: No response")
return SS
def MAIL_get_verification_link(self, mailSessionID=None, subjectPattern=None, linkPattern=r"", mailService="Guerrilla", timeout=10):
import re
if mailService == "Guerrilla":
_mailSession = GuerrillaMailSession(mailSessionID)
if timeout:
from datetime import datetime
start_time = datetime.now()
while True:
for mail in _mailSession.get_email_list():
if subjectPattern in mail.subject:
fetch_mail = _mailSession.get_email(mail.guid)
body = fetch_mail.body
m = re.search(linkPattern, body)
if m:
link = m.group('veri_link')
print("LINK FOUND: "+link)
return link
time.sleep(2)
if timeout:
current_time = datetime.now()
interval = current_time - start_time
if interval > timeout:
print("{{MAIL_get_verification_link}} TIMEOUT!!!")
return None
return None
def __init__(self, addr="*****@*****.**", random_name=False):
if not random_name:
self.session = GuerrillaMailSession(email_address=addr)
else:
r_addr = self.get_random_name()
print(r_addr)
self.session = GuerrillaMailSession(email_address=r_addr)
def gen_account_creds():
session = GuerrillaMailSession()
with open('short_words.json', 'r') as file:
words = json.load(file)
user_name_opts = {
'camel_case':
choice(words) + choice(words).title(),
'camel_case_num':
choice(words) + choice(words).title() + str(randint(0, 5000)),
'flat_num':
choice(words) + str(randint(0, 50000)),
'upper':
choice(words).upper() + str(randint(0, 50000)),
'upper_lower':
choice(words).upper() + choice(words)
}
account = {
'email': session.get_session_state()['email_address'],
'pass': token_urlsafe(16),
'user': user_name_opts[choice(list(user_name_opts.keys()))]
}
return account
def get(seq):
SS = ss.SS("PSS")
SS.status = 0
if time.time() < 1571702400.00:
SS.pred = "PSS down until Oct 22"
SS.conf = "PSS down until Oct 22"
SS.status = 2
return SS
if (len(seq) > 4000):
SS.pred += "Sequence longer than 4000"
SS.conf += "Sequence longer than 4000"
SS.status = 2 #error status
print("PSSPred failed: Sequence longer than 4000")
return SS #return SS so it will be readable as an ssObject
session = GuerrillaMailSession() #Creates GuerrillaMail session
email_address = session.get_session_state()['email_address'] #retrieves temp email address
payload = {'REPLY-E-MAIL': email_address,
'TARGET-NAME': 'testprot',
'SEQUENCE': seq}
#Around 15 min for 4000
r= requests.post('https://zhanglab.ccmb.med.umich.edu/cgi-bin/PSSpred.pl', data=payload)
soup = BeautifulSoup(r.text, 'html.parser')
#Exit if no links available in the response
if soup.a is None:
SS.pred = "Failed to submit, server possibly under load"
SS.conf = "Failed to submit, server possibly under load"
SS.status = 2
return SS
ssurl = soup.a.get('href')
ssurl = ssurl + '/seq.SS'
requesturl = batchtools.requestWait(ssurl, "PSSpred Not Ready")
if requesturl:
raw = requesturl.text.splitlines()
for i in range(len(raw)):
if raw[i].startswith("conf"):
SS.conf += raw[i][6:].strip()
if raw[i].startswith("SS"):
SS.pred += raw[i][6:].strip()
SS.status = 1
print("PSSPred Complete")
else:
SS.pred += "PSSPred failed to respond in time"
SS.conf += "PSSPred failed to respond in time"
SS.status = 2 #error status
print("PSSPred failed: No response")
return SS
def test_cli_should_create_session_using_settings(self,
GuerrillaMailSession,
load_settings, **kwargs):
self.setup_mocks(GuerrillaMailSession=GuerrillaMailSession,
load_settings=load_settings,
**kwargs)
load_settings.return_value = {'arg1': 1, 'arg2': 'cheese'}
cli()
GuerrillaMailSession.assert_called_with(arg1=1, arg2='cheese')
def MAIL_get_verification_link(self,
mailSessionID=None,
subjectPattern=None,
linkPattern=r"",
mailService="Guerrilla"):
import re
if mailService == "Guerrilla":
_mailSession = GuerrillaMailSession(mailSessionID)
while True:
for mail in _mailSession.get_email_list():
if subjectPattern in mail.subject:
fetch_mail = _mailSession.get_email(mail.guid)
body = fetch_mail.body
print(body)
m = re.search(linkPattern, body)
if m:
link = m.group('veri_link')
print("LINK FOUND: " + link)
return link
time.sleep(2)
return None
def gen_acct(driver, first_name, last_name):
session = GuerrillaMailSession()
try:
elem = driver.find_element_by_id("password")
#i = 0
#while(True):
# i = i + 1
action = ActionChains(driver)
action.send_keys(Keys.TAB * 7)
#print(i)
action.perform()
action = ActionChains(driver)
action.send_keys(Keys.RETURN)
action.perform()
except:
elem = driver.find_element_by_id("email")
action = ActionChains(driver)
action.send_keys(Keys.TAB * 2)
action.perform()
action = ActionChains(driver)
action.send_keys(Keys.RETURN)
action.perform()
elem = driver.find_element_by_id("first-name-su")
elem.send_keys(first_name)
elem = driver.find_element_by_id("last-name-su")
elem.send_keys(last_name)
elem = driver.find_element_by_id("email-su")
elem.send_keys(session.get_session_state()['email_address'])
import string
password = string.ascii_letters + string.digits + string.punctuation
elem = driver.find_element_by_id("password-su")
elem.send_keys(password)
action = ActionChains(driver)
action.send_keys(Keys.TAB * 7)
#print(i)
action.perform()
action = ActionChains(driver)
action.send_keys(Keys.RETURN)
action.perform()
def custom_guerrilla_mail_session(self, **kwargs):
"""
get new email -> read the content -> click link
"""
aSession = GuerrillaMailSession()
aSession.get_session_state()
aSession.set_email_address(kwargs['username'])
return aSession
def read_email(email):
s = GuerrillaMailSession()
s.set_email_address(email)
print(s.get_session_state())
for email in s.get_email_list():
if email.subject == "Poliigon: Email Verification":
print("Got email")
body = s.get_email(s.get_email_list()[0].guid).body
link = body[body.index("https://www.poliigon.com"
):body.index("https://www.poliigon.com") +
71]
return link
def before_scenario(context, scenario):
# We set our Guerrilla email. this is the temporary email service.
context.email_session = GuerrillaMailSession()
context.temp_email = context.email_session.get_session_state()['email_address']
# Start browser
options = chrome_options()
# options = firefox_options()
options.add_argument("--start-maximized")
options.add_argument("--incognito")
options.add_argument("--private")
# options.add_argument("--headless")
# context.browser = webdriver.Edge()
context.browser = Browser(browser='chrome', options=options)
context.browser.window().maximize()
# We create a dict to store the data of the fake user
context.fake_user = dict()
# Print which scenario we are about to test
print(f'Starting test for {scenario.tags[0]}: {context.scenario.name}\n')
def setup_mocks(self, GuerrillaMailClient, **kwargs):
self.mock_client = Mock()
GuerrillaMailClient.return_value = self.mock_client
self.session = GuerrillaMailSession()
#!/usr/bin/env python3
from guerrillamail import GuerrillaMailSession
import smtplib
import sys
import os.path as op
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email.mime.text import MIMEText
from email.utils import COMMASPACE, formatdate
from email import encoders
from bs4 import BeautifulSoup
session = GuerrillaMailSession()
# Gets temporarly email from guerrila mail
_from = session.get_session_state()['email_address'] #Get current email from seassion
argc = len(sys.argv)
print("Argument count: " + str(argc))
if argc <= 3:
print("You must enter 3 or 4 arguments, you entered: " + str(argc))
print("You must enter: Username, Mail Service Name, Job Title")
exit()
elif argc >= 4:
_username = sys.argv[1]
_mail_service_name = sys.argv[2]
_job_title = sys.argv[3]
_to = _username + "@" + _mail_service_name
if argc == 5:
class GuerrillaMailSessionTest(TestCase):
def setup_mocks(self, GuerrillaMailClient, **kwargs):
self.mock_client = Mock()
GuerrillaMailClient.return_value = self.mock_client
self.session = GuerrillaMailSession()
def test_get_email_state_should_extract_email_address_from_response(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_address.return_value = {'email_addr': '*****@*****.**', 'sid_token': 1}
email_address = self.session.get_session_state()
expect(email_address).to.equal({'email_address': '*****@*****.**'})
def test_get_email_state_should_call_client(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_address.return_value = {'email_addr': '', 'sid_token': 1}
self.session.get_session_state()
self.mock_client.get_email_address.assert_called_once_with(session_id=None)
def test_get_session_state_should_call_client_with_session_id_when_set(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_address.return_value = {'email_addr': ''}
self.session.session_id = 1
self.session.get_session_state()
self.mock_client.get_email_address.assert_called_once_with(session_id=1)
def test_get_session_state_should_update_session_id_when_included_in_response(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_address.return_value = {'email_addr': '', 'sid_token': 1}
assert self.session.session_id == None
self.session.get_session_state()
expect(self.session.session_id).to.equal(1)
def test_get_session_state_should_not_update_session_id_when_not_included_in_response(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_address.return_value = {'email_addr': ''}
self.session.session_id = 1
self.session.get_session_state()
expect(self.session.session_id).to.equal(1)
def test_get_session_state_should_update_email_timestamp(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_address.return_value = {'email_addr': '', 'email_timestamp': 1234, 'sid_token': 1}
assert self.session.email_timestamp == 0
self.session.get_session_state()
expect(self.session.email_timestamp).to.equal(1234)
def test_get_session_state_should_update_email_address(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_address.return_value = {
'email_addr': '*****@*****.**', 'email_timestamp': 1234, 'sid_token': 1,
}
assert self.session.email_timestamp == 0
self.session.get_session_state()
expect(self.session.email_address).to.equal('*****@*****.**')
def test_get_session_state_should_use_cached_data_when_available_and_current(self, **kwargs):
self.setup_mocks(**kwargs)
self.session.session_id = 1
self.session.email_address = '*****@*****.**'
self.session.email_timestamp = current_timestamp()
self.session.get_session_state()
expect(self.mock_client.get_email_address.called).to.equal(False)
expect(self.mock_client.set_email_address.called).to.equal(False)
def test_set_email_address_should_return_none(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.set_email_address.return_value = {'email_addr': '*****@*****.**'}
result = self.session.set_email_address('newaddr')
expect(result).to.be.none
def test_set_email_address_should_call_client(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.set_email_address.return_value = {'email_addr': ''}
self.session.set_email_address('newaddr')
self.mock_client.set_email_address.assert_called_once_with(session_id=None, address_local_part='newaddr')
def test_set_email_address_should_call_client_with_session_id_when_set(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.set_email_address.return_value = {'email_addr': ''}
self.session.session_id = 1
self.session.set_email_address('newaddr')
self.mock_client.set_email_address.assert_called_once_with(session_id=1, address_local_part='newaddr')
def test_set_email_address_should_update_session_id_when_included_in_response(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.set_email_address.return_value = {'email_addr': '', 'sid_token': 1}
assert self.session.session_id == None
self.session.set_email_address('newaddr')
expect(self.session.session_id).to.equal(1)
def test_set_email_address_should_not_update_session_id_when_not_included_in_response(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.set_email_address.return_value = {'email_addr': ''}
self.session.session_id = 1
self.session.set_email_address('newaddr')
expect(self.session.session_id).to.equal(1)
def test_set_email_address_should_update_email_timestamp(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.set_email_address.return_value = {'email_addr': '', 'email_timestamp': 1234}
assert self.session.email_timestamp == 0
self.session.set_email_address('newaddr')
expect(self.session.email_timestamp).to.equal(1234)
def test_set_email_address_should_update_email_address(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.set_email_address.return_value = {'email_addr': '*****@*****.**', 'email_timestamp': 1234}
assert self.session.email_timestamp == 0
self.session.set_email_address('newaddr')
expect(self.session.email_address).to.equal('*****@*****.**')
def test_get_email_list_should_extract_response_list(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.session.session_id = 1
self.session.email_timestamp = current_timestamp()
email_list = self.session.get_email_list()
expect(email_list).to.have.length_of(0)
def test_get_email_list_should_create_mail_instances_from_response_list(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {
'list': [{
'mail_id': '1',
'mail_subject': 'Hello',
'mail_from': '*****@*****.**',
'mail_timestamp': '1392501749',
'mail_read': '0',
'mail_exerpt': 'Hi there....',
}]
}
self.session.session_id = 1
self.session.email_timestamp = current_timestamp()
email_list = self.session.get_email_list()
email = email_list[0]
expect(email_list).to.have.length_of(1)
expect(email).to.have.property('guid').with_value.being.equal('1')
expect(email).to.have.property('subject').with_value.being.equal('Hello')
expect(email).to.have.property('sender').with_value.being.equal('*****@*****.**')
expect(email).to.have.property('datetime').with_value.being.equal(datetime(2014, 2, 15, 22, 2, 29, tzinfo=utc))
expect(email).to.have.property('read').with_value.being.false
expect(email).to.have.property('exerpt').with_value.being.equal('Hi there....')
def test_get_email_list_should_call_client(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.session.session_id = 1
self.session.email_timestamp = current_timestamp()
self.session.get_email_list()
self.mock_client.get_email_list.assert_called_once_with(session_id=1, offset=0)
def test_get_email_list_should_call_client_with_session_id_when_set(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.session.session_id = 1
self.session.email_timestamp = current_timestamp()
self.session.get_email_list()
self.mock_client.get_email_list.assert_called_once_with(session_id=1, offset=0)
def test_get_email_list_should_update_session_id_when_included_in_response(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': [], 'sid_token': 1}
self.session.session_id = 0
self.session.email_timestamp = current_timestamp()
self.session.get_email_list()
expect(self.session.session_id).to.equal(1)
def test_get_email_list_should_not_update_session_id_when_not_included_in_response(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.session.session_id = 1
self.session.email_timestamp = current_timestamp()
self.session.get_email_list()
expect(self.session.session_id).to.equal(1)
def test_get_email_list_should_not_invoke_get_address_when_session_id_set_and_not_expired(self, **kwargs):
self.setup_mocks(**kwargs)
self.session.session_id = 1
self.session.email_timestamp = current_timestamp()
self.mock_client.get_email_list.return_value = {'list': []}
self.session.get_email_list()
expect(self.mock_client.get_email_address.called).to.equal(False)
def test_get_email_list_should_first_create_session_when_session_id_not_set(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.mock_client.get_email_address.return_value = {'sid_token': '1', 'email_addr': ''}
self.session.email_timestamp = current_timestamp()
assert self.session.session_id == None
self.session.get_email_list()
expect(self.session.session_id).to.equal('1')
self.mock_client.get_email_list.assert_called_once_with(session_id='1', offset=0)
def test_get_email_list_should_first_create_session_and_reuse_address_when_session_id_not_set(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.mock_client.set_email_address.return_value = {'sid_token': '1', 'email_addr': ''}
self.session.email_timestamp = current_timestamp()
self.session.email_address = '*****@*****.**'
assert self.session.session_id == None
self.session.get_email_list()
expect(self.session.session_id).to.equal('1')
self.mock_client.get_email_list.assert_called_once_with(session_id='1', offset=0)
def test_get_email_list_should_fail_when_session_cannot_be_obtained(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_address.return_value = {'email_addr': ''}
assert self.session.session_id == None
expect(self.session.get_email_list).when.called.to.throw(GuerrillaMailException)
expect(self.mock_client.get_email_list.called).to.equal(False)
def test_get_email_list_should_refresh_session_when_email_expired(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.mock_client.get_email_address.return_value = {'email_addr': '', 'sid_token': '2', 'email_timestamp': 1234}
self.session.session_id = 1
self.session.email_timestamp = current_timestamp() - 3600
self.session.get_email_list()
expect(self.session.session_id).to.equal('2')
expect(self.session.email_timestamp).to.equal(1234)
self.mock_client.get_email_list.assert_called_once_with(session_id='2', offset=0)
def test_get_email_list_should_refresh_session_and_reuse_address_when_email_expired(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.mock_client.set_email_address.return_value = {'email_addr': '', 'sid_token': '2', 'email_timestamp': 1234}
self.session.session_id = 1
self.session.email_address = '*****@*****.**'
self.session.email_timestamp = current_timestamp() - 3600
self.session.get_email_list()
expect(self.session.session_id).to.equal('2')
expect(self.session.email_timestamp).to.equal(1234)
self.mock_client.get_email_list.assert_called_once_with(session_id='2', offset=0)
def test_get_email_list_should_not_refresh_session_when_email_not_expired(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.session.session_id = 1
self.session.email_timestamp = current_timestamp() - 3590
self.session.get_email_list()
expect(self.mock_client.get_email_address.called).to.equal(False)
def test_get_email_should_create_mail_instance_from_client_response_data(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email.return_value = {
'mail_id': '1',
'mail_subject': 'Hello',
'mail_from': '*****@*****.**',
'mail_timestamp': '1392501749',
'mail_read': '0',
'mail_exerpt': 'Hi there....',
'mail_body': 'Hi there partner',
}
email = self.session.get_email('123')
expect(email).to.have.property('guid').with_value.being.equal('1')
expect(email).to.have.property('subject').with_value.being.equal('Hello')
expect(email).to.have.property('sender').with_value.being.equal('*****@*****.**')
expect(email).to.have.property('datetime').with_value.being.equal(datetime(2014, 2, 15, 22, 2, 29, tzinfo=utc))
expect(email).to.have.property('read').with_value.being.false
expect(email).to.have.property('exerpt').with_value.being.equal('Hi there....')
expect(email).to.have.property('body').with_value.being.equal('Hi there partner')
def test_get_email_should_call_client(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email.return_value = {}
self.session.get_email('123')
self.mock_client.get_email.assert_called_once_with(email_id='123', session_id=None)
def test_get_email_should_call_client_with_session_id_when_set(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email.return_value = {}
self.session.session_id = 1
self.session.get_email('123')
self.mock_client.get_email.assert_called_once_with(email_id='123', session_id=1)
def test_get_email_should_update_session_id_when_included_in_response(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email.return_value = {'sid_token': 1}
assert self.session.session_id == None
self.session.get_email('123')
expect(self.session.session_id).to.equal(1)
def test_get_email_should_not_update_session_id_when_not_included_in_response(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email.return_value = {}
self.session.session_id = 1
self.session.get_email('123')
expect(self.session.session_id).to.equal(1)
def __init__(self, user_name):
self.session = GuerrillaMailSession()
self.user_name = user_name
self.session.set_email_address(self.user_name)
self.user_email = self.session.get_session_state()['email_address']
def __init__(self, user_name):
self.session = GuerrillaMailSession()
self.user_name = user_name
self.session.set_email_address(self.user_name)
self.user_email = self.session.get_session_state()['email_address']
MainPassword = getpass.getpass(prompt="[*] Password: "******"[*] Who Would You Like To Send The Email To: ")
sleep(1.5)
MainMessage = input("[*] What Would You Like The Email To Say: ")
sleep(2)
print("[*] Email Successfully Sent!")
server = smtplib.SMTP('smtp.mail.yahoo.com', 587)
server.starttls()
server.login(MainLogin, MainPassword)
msg = (MainMessage)
server.sendmail(MainLogin, MainContact, msg)
server.quit()
elif option == '4':
print("[*] Email Address Only Lasts For 60 Minutes.")
sleep(1)
print("[*] Generating Email...")
sleep(1.5)
session = GuerrillaMailSession()
print(session.get_session_state()['email_address'])
print("[*] Enjoy Your ThrowAway Email!")
elif option == '5':
server = smtplib.SMTP('smtp.gmail.com', 587)
server.quit()
def get(seq):
SS = ss.SS("SSPro")
SS.status = 0
if (len(seq) > 400):
SS.pred += "Sequence longer than 400"
SS.conf += "Sequence longer than 400"
SS.status = 2 #error status
print("SSPro failed: Sequence longer than 400")
return SS #return SS so it will be readable as an ssObject
randName = batchtools.randBase62()
session = GuerrillaMailSession() #Creates GuerrillaMail session
email_address = session.get_session_state()[
'email_address'] #retrieves temp email address
payload = {
'amino_acids': seq,
'query_name': randName,
'email': email_address,
'ss': 'on'
}
r = requests.post(
'http://scratch.proteomics.ics.uci.edu/cgi-bin/new_server/sql_predict.cgi',
data=payload)
soup = BeautifulSoup(r.text, 'html.parser')
msg = soup.find('p')
if msg == None:
SS.pred += "Failed to Submit"
SS.conf += "Failed to Submit"
SS.status = 2 #error status
print("SSPro Failed to Submit")
return SS
if msg.text.split()[0] == 'ERROR:':
SS.pred += "Queue Full"
SS.conf += "Queue Full"
SS.status = 2 #error status
print("SSPro Queue Full")
return SS
query = 'from:([email protected]) subject:(Protein Structure Predictions for ' + randName + ')'
stime = time.time()
email_id = False
#Waits indefinitely until results are out
email_id, message = batchtools.emailRequestWait(session, query, "Name:",
randName,
"SSPro Not Ready", 60)
#Cancels after 15 min. Length 400 sequences take 10-15 min in a batch
#email_id, message = batchtools.emailRequestWait(session, query, "Name:", randName, "SSPro Not Ready", 60, 900)
if email_id:
message_parts = message.splitlines()
index = 0 #current line
finished_scrape = False
while index < len(message_parts) and not finished_scrape:
index += 1
if message_parts[
index] == "Predicted Secondary Structure (3 Class):":
while message_parts[index]: #while not blank line
index += 1
SS.pred += message_parts[index]
finished_scrape = True
SS.conf = "SSPro Does Not Provide Any Conf"
SS.status = 3
print("SSpro Complete")
else:
SS.pred += "SSPro failed to respond in time"
SS.conf += "SSPro failed to respond in time"
SS.status = 2 #error status
print("SSPro failed: No response")
return SS
def test_main_should_create_session_using_settings(self, GuerrillaMailSession, load_settings, **kwargs):
self.setup_mocks(GuerrillaMailSession=GuerrillaMailSession, load_settings=load_settings, **kwargs)
load_settings.return_value = {'arg1': 1, 'arg2': 'cheese'}
main()
GuerrillaMailSession.assert_called_with(arg1=1, arg2='cheese')
def get(seq):
SS = ss.SS("PSI")
if (len(seq) < 30 or len(seq) > 1500):
SS.pred += "Sequence is shorter than 30 or longer than 1500"
SS.conf += "Sequence is shorter than 30 or longer than 1500"
SS.status = 2 #error status
print("PsiPred failed: Sequence is shorter than 30 or longer than 1500")
return SS #return SS so it will be readable as an ssObject
session = GuerrillaMailSession() #Creates GuerrillaMail session
email_address = session.get_session_state()['email_address'] #retrieves temp email address
url = 'http://bioinf.cs.ucl.ac.uk/psipred/api/submission/'
payload = {'input_data': seq}
data = {'job': 'psipred',
'submission_name': 'testing',
'email': email_address, }
r = requests.post(url, data=data, files=payload, headers={'accept': 'application/json'})
try: #try/catch in case a nucleotide/invalid sequence is entered
uuid = r.json()['UUID']
jsonurl = 'http://bioinf.cs.ucl.ac.uk/psipred/api/submission/' + uuid + '?format=json'
r = requests.get(jsonurl)
filesUUID = r.json()['submissions'][0]['UUID']
horiz = 'http://bioinf.cs.ucl.ac.uk/psipred/api/submissions/' + filesUUID + '.horiz'
#Length 1500 takes around 5 min
requesturl = batchtools.requestWait(horiz, 'PsiPred Not Ready')
if requesturl:
raw = requesturl.text.splitlines()
for i in range(len(raw)):
raw[i] = raw[i].strip()
if raw[i].startswith("Conf"):
SS.conf += raw[i][6:]
if raw[i].startswith("Pred"):
SS.pred += raw[i][6:]
SS.status = 1
print("PsiPred Complete")
else:
SS.pred += "PsiPred failed to respond in time"
SS.conf += "PsiPred failed to respond in time"
SS.status = 2 #error status
print("PsiPred failed: No response")
except:
SS.pred += "PsiPred failed: sequence not accepted"
SS.conf += "PsiPred failed: sequence not accepted"
SS.status = 4
print("PsiPred failed: sequence not accepted")
print("PSI::")
print(SS.pred)
print(SS.conf)
return SS
class GuerrillaMailApi(object):
"""
Api for using Guerrilla Mail.
"""
def __init__(self, user_name):
self.session = GuerrillaMailSession()
self.user_name = user_name
self.session.set_email_address(self.user_name)
self.user_email = self.session.get_session_state()['email_address']
def get_email_text(self, pattern):
"""
Get email text from GuerrillaMail server.
Checks the latest email from the inbox and searches for pattern in it.
If pattern is found then email's body is returned otherwise exception
is raised. Also, if latest email is not from MIT, it raises exception.
Checks GuerrillaMail server for email at the intervals of 5 seconds.
If the email is not found after 40 seconds then exception is raised.
Arguments:
pattern(str): Pattern to be found in the email's body.
Returns:
str: Email's body.
"""
email_text = ""
t_end = time.time() + TIME_OUT_LIMIT
# Run the loop for a pre defined time
time.sleep(INITIAL_WAIT_TIME)
while time.time() < t_end:
try:
# Check that mail box is not empty
email_list = self.session.get_email_list()
if not email_list:
# raise an exception that waits 3 seconds
# before restarting loop
raise MailException
# Get the email id of last email in the inbox
email_id = email_list[0].guid
# if last email is not sent by MIT raise the exception
email = self.session.get_email(email_id)
if email.sender != EMAIL_SENDER_ACCOUNT:
raise MailException
# Fetch the email text and stop the loop
email_text = email.body
if pattern not in email_text:
raise MailException
break
except MailException:
time.sleep(WAIT_TIME)
if email_text:
return email_text
else:
raise MailException('No Email from ' + EMAIL_SENDER_ACCOUNT)
def get_url_from_email(self, matching_string):
"""
Connect to the email client
Get text of target email
fetch desired url from the email text
Args:
matching_string:
Returns:
target url:
"""
email_text = self.get_email_text(
self.user_email
)
return get_target_url_from_text(matching_string, email_text)
def setup_mocks(self, GuerrillaMailClient, **kwargs):
self.mock_client = Mock()
GuerrillaMailClient.return_value = self.mock_client
self.session = GuerrillaMailSession()
class GuerrillaMailSessionTest(TestCase):
def setup_mocks(self, GuerrillaMailClient, **kwargs):
self.mock_client = Mock()
GuerrillaMailClient.return_value = self.mock_client
self.session = GuerrillaMailSession()
def test_get_email_state_should_extract_email_address_from_response(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_address.return_value = {
'email_addr': '*****@*****.**',
'sid_token': 1
}
email_address = self.session.get_session_state()
expect(email_address).to.equal({'email_address': '*****@*****.**'})
def test_get_email_state_should_call_client(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_address.return_value = {
'email_addr': '',
'sid_token': 1
}
self.session.get_session_state()
self.mock_client.get_email_address.assert_called_once_with(
session_id=None)
def test_get_session_state_should_call_client_with_session_id_when_set(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_address.return_value = {'email_addr': ''}
self.session.session_id = 1
self.session.get_session_state()
self.mock_client.get_email_address.assert_called_once_with(
session_id=1)
def test_get_session_state_should_update_session_id_when_included_in_response(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_address.return_value = {
'email_addr': '',
'sid_token': 1
}
assert self.session.session_id == None
self.session.get_session_state()
expect(self.session.session_id).to.equal(1)
def test_get_session_state_should_not_update_session_id_when_not_included_in_response(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_address.return_value = {'email_addr': ''}
self.session.session_id = 1
self.session.get_session_state()
expect(self.session.session_id).to.equal(1)
def test_get_session_state_should_update_email_timestamp(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_address.return_value = {
'email_addr': '',
'email_timestamp': 1234,
'sid_token': 1
}
assert self.session.email_timestamp == 0
self.session.get_session_state()
expect(self.session.email_timestamp).to.equal(1234)
def test_get_session_state_should_update_email_address(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_address.return_value = {
'email_addr': '*****@*****.**',
'email_timestamp': 1234,
'sid_token': 1,
}
assert self.session.email_timestamp == 0
self.session.get_session_state()
expect(self.session.email_address).to.equal('*****@*****.**')
def test_get_session_state_should_use_cached_data_when_available_and_current(
self, **kwargs):
self.setup_mocks(**kwargs)
self.session.session_id = 1
self.session.email_address = '*****@*****.**'
self.session.email_timestamp = current_timestamp()
self.session.get_session_state()
expect(self.mock_client.get_email_address.called).to.equal(False)
expect(self.mock_client.set_email_address.called).to.equal(False)
def test_set_email_address_should_return_none(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.set_email_address.return_value = {
'email_addr': '*****@*****.**'
}
result = self.session.set_email_address('newaddr')
expect(result).to.be.none
def test_set_email_address_should_call_client(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.set_email_address.return_value = {'email_addr': ''}
self.session.set_email_address('newaddr')
self.mock_client.set_email_address.assert_called_once_with(
session_id=None, address_local_part='newaddr')
def test_set_email_address_should_call_client_with_session_id_when_set(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.set_email_address.return_value = {'email_addr': ''}
self.session.session_id = 1
self.session.set_email_address('newaddr')
self.mock_client.set_email_address.assert_called_once_with(
session_id=1, address_local_part='newaddr')
def test_set_email_address_should_update_session_id_when_included_in_response(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.set_email_address.return_value = {
'email_addr': '',
'sid_token': 1
}
assert self.session.session_id == None
self.session.set_email_address('newaddr')
expect(self.session.session_id).to.equal(1)
def test_set_email_address_should_not_update_session_id_when_not_included_in_response(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.set_email_address.return_value = {'email_addr': ''}
self.session.session_id = 1
self.session.set_email_address('newaddr')
expect(self.session.session_id).to.equal(1)
def test_set_email_address_should_update_email_timestamp(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.set_email_address.return_value = {
'email_addr': '',
'email_timestamp': 1234
}
assert self.session.email_timestamp == 0
self.session.set_email_address('newaddr')
expect(self.session.email_timestamp).to.equal(1234)
def test_set_email_address_should_update_email_address(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.set_email_address.return_value = {
'email_addr': '*****@*****.**',
'email_timestamp': 1234
}
assert self.session.email_timestamp == 0
self.session.set_email_address('newaddr')
expect(self.session.email_address).to.equal('*****@*****.**')
def test_get_email_list_should_extract_response_list(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.session.session_id = 1
self.session.email_timestamp = current_timestamp()
email_list = self.session.get_email_list()
expect(email_list).to.have.length_of(0)
def test_get_email_list_should_create_mail_instances_from_response_list(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {
'list': [{
'mail_id': '1',
'mail_subject': 'Hello',
'mail_from': '*****@*****.**',
'mail_timestamp': '1392501749',
'mail_read': '0',
'mail_exerpt': 'Hi there....',
}]
}
self.session.session_id = 1
self.session.email_timestamp = current_timestamp()
email_list = self.session.get_email_list()
email = email_list[0]
expect(email_list).to.have.length_of(1)
expect(email).to.have.property('guid').with_value.being.equal('1')
expect(email).to.have.property('subject').with_value.being.equal(
'Hello')
expect(email).to.have.property('sender').with_value.being.equal(
'*****@*****.**')
expect(email).to.have.property('datetime').with_value.being.equal(
datetime(2014, 2, 15, 22, 2, 29, tzinfo=utc))
expect(email).to.have.property('read').with_value.being.false
expect(email).to.have.property('exerpt').with_value.being.equal(
'Hi there....')
def test_get_email_list_should_call_client(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.session.session_id = 1
self.session.email_timestamp = current_timestamp()
self.session.get_email_list()
self.mock_client.get_email_list.assert_called_once_with(session_id=1,
offset=0)
def test_get_email_list_should_call_client_with_session_id_when_set(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.session.session_id = 1
self.session.email_timestamp = current_timestamp()
self.session.get_email_list()
self.mock_client.get_email_list.assert_called_once_with(session_id=1,
offset=0)
def test_get_email_list_should_update_session_id_when_included_in_response(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {
'list': [],
'sid_token': 1
}
self.session.session_id = 0
self.session.email_timestamp = current_timestamp()
self.session.get_email_list()
expect(self.session.session_id).to.equal(1)
def test_get_email_list_should_not_update_session_id_when_not_included_in_response(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.session.session_id = 1
self.session.email_timestamp = current_timestamp()
self.session.get_email_list()
expect(self.session.session_id).to.equal(1)
def test_get_email_list_should_not_invoke_get_address_when_session_id_set_and_not_expired(
self, **kwargs):
self.setup_mocks(**kwargs)
self.session.session_id = 1
self.session.email_timestamp = current_timestamp()
self.mock_client.get_email_list.return_value = {'list': []}
self.session.get_email_list()
expect(self.mock_client.get_email_address.called).to.equal(False)
def test_get_email_list_should_first_create_session_when_session_id_not_set(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.mock_client.get_email_address.return_value = {
'sid_token': '1',
'email_addr': ''
}
self.session.email_timestamp = current_timestamp()
assert self.session.session_id == None
self.session.get_email_list()
expect(self.session.session_id).to.equal('1')
self.mock_client.get_email_list.assert_called_once_with(session_id='1',
offset=0)
def test_get_email_list_should_first_create_session_and_reuse_address_when_session_id_not_set(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.mock_client.set_email_address.return_value = {
'sid_token': '1',
'email_addr': ''
}
self.session.email_timestamp = current_timestamp()
self.session.email_address = '*****@*****.**'
assert self.session.session_id == None
self.session.get_email_list()
expect(self.session.session_id).to.equal('1')
self.mock_client.get_email_list.assert_called_once_with(session_id='1',
offset=0)
def test_get_email_list_should_fail_when_session_cannot_be_obtained(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_address.return_value = {'email_addr': ''}
assert self.session.session_id == None
expect(self.session.get_email_list).when.called.to.throw(
GuerrillaMailException)
expect(self.mock_client.get_email_list.called).to.equal(False)
def test_get_email_list_should_refresh_session_when_email_expired(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.mock_client.get_email_address.return_value = {
'email_addr': '',
'sid_token': '2',
'email_timestamp': 1234
}
self.session.session_id = 1
self.session.email_timestamp = current_timestamp() - 3600
self.session.get_email_list()
expect(self.session.session_id).to.equal('2')
expect(self.session.email_timestamp).to.equal(1234)
self.mock_client.get_email_list.assert_called_once_with(session_id='2',
offset=0)
def test_get_email_list_should_refresh_session_and_reuse_address_when_email_expired(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.mock_client.set_email_address.return_value = {
'email_addr': '',
'sid_token': '2',
'email_timestamp': 1234
}
self.session.session_id = 1
self.session.email_address = '*****@*****.**'
self.session.email_timestamp = current_timestamp() - 3600
self.session.get_email_list()
expect(self.session.session_id).to.equal('2')
expect(self.session.email_timestamp).to.equal(1234)
self.mock_client.get_email_list.assert_called_once_with(session_id='2',
offset=0)
def test_get_email_list_should_not_refresh_session_when_email_not_expired(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email_list.return_value = {'list': []}
self.session.session_id = 1
self.session.email_timestamp = current_timestamp() - 3590
self.session.get_email_list()
expect(self.mock_client.get_email_address.called).to.equal(False)
def test_get_email_should_create_mail_instance_from_client_response_data(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email.return_value = {
'mail_id': '1',
'mail_subject': 'Hello',
'mail_from': '*****@*****.**',
'mail_timestamp': '1392501749',
'mail_read': '0',
'mail_exerpt': 'Hi there....',
'mail_body': 'Hi there partner',
}
email = self.session.get_email('123')
expect(email).to.have.property('guid').with_value.being.equal('1')
expect(email).to.have.property('subject').with_value.being.equal(
'Hello')
expect(email).to.have.property('sender').with_value.being.equal(
'*****@*****.**')
expect(email).to.have.property('datetime').with_value.being.equal(
datetime(2014, 2, 15, 22, 2, 29, tzinfo=utc))
expect(email).to.have.property('read').with_value.being.false
expect(email).to.have.property('exerpt').with_value.being.equal(
'Hi there....')
expect(email).to.have.property('body').with_value.being.equal(
'Hi there partner')
def test_get_email_should_call_client(self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email.return_value = {}
self.session.get_email('123')
self.mock_client.get_email.assert_called_once_with(email_id='123',
session_id=None)
def test_get_email_should_call_client_with_session_id_when_set(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email.return_value = {}
self.session.session_id = 1
self.session.get_email('123')
self.mock_client.get_email.assert_called_once_with(email_id='123',
session_id=1)
def test_get_email_should_update_session_id_when_included_in_response(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email.return_value = {'sid_token': 1}
assert self.session.session_id == None
self.session.get_email('123')
expect(self.session.session_id).to.equal(1)
def test_get_email_should_not_update_session_id_when_not_included_in_response(
self, **kwargs):
self.setup_mocks(**kwargs)
self.mock_client.get_email.return_value = {}
self.session.session_id = 1
self.session.get_email('123')
expect(self.session.session_id).to.equal(1)
class Silverback(object):
full_path = os.path.realpath(__file__)
directory = os.path.dirname(full_path)
data_folder = directory + "//guerrilla_data"
list_of_names_file = directory + "/nounlist.txt"
def __init__(self, addr="*****@*****.**", random_name=False):
if not random_name:
self.session = GuerrillaMailSession(email_address=addr)
else:
r_addr = self.get_random_name()
print(r_addr)
self.session = GuerrillaMailSession(email_address=r_addr)
def get_random_name(self):
random_noun = random.choice(open(
self.list_of_names_file).readlines())[0:-1]
return random_noun + "@sharklasers.com"
def print_body(self, offset=0):
print(
self.session.get_email(
self.session.get_email_list()[offset].guid).body)
def get_all_mail(self):
mails = []
for g in self.session.get_email_list():
mails.append(self.session.get_email(g.guid))
return mails
def clean_text(self, rgx_list, text):
new_text = text
for rgx_match in rgx_list:
new_text = re.sub(rgx_match, ' ', new_text)
return new_text
def get_current_file(self):
n = datetime.datetime.now()
d = str(n.month) + "-" + str(n.day) + "-" + str(n.year)
return self.data_folder + r"/" + d + ".csv"
def search_and_write(self):
mails = self.get_all_mail()
counter = 0
pattern = "([\w]+[\w\s]*)(?=[\'" "\s]*<{1})"
name_of_writing_file = self.get_current_file()
with open(name_of_writing_file, 'a', newline='',
encoding='utf-8') as csv_file:
writer = csv.writer(csv_file, delimiter=';')
for item in mails:
f = item.sender
s = item.subject
j = self.clean_text(["<(.*?)>", "(\r\n|\r|\n)"], item.body)
if s and f and j:
if not f == "*****@*****.**":
writer.writerow([f, s, j])
counter += 3
print("wrote %i pieces of data to csv" % counter)
from guerrillamail import GuerrillaMailSession, GuerrillaMailClient
session = GuerrillaMailSession()
print session.get_session_state()['email_address']
print session.get_email_list()[0].guid
print session.get_email(1).guid
client = GuerrillaMailClient()
email_data = client.get_email(1)
print email_data.get('mail_from')
def get(seq):
SS = ss.SS("JPred")
if (len(seq) < 20 or len(seq) > 800):
SS.pred += "Sequence is shorter than 20 or longer than 800"
SS.conf += "Sequence is shorter than 20 or longer than 800"
SS.status = 2 #error status
print("JPred failed: Sequence is shorter than 20 or longer than 800")
return SS #return SS so it will be readable as an ssObject
session = GuerrillaMailSession() #Creates GuerrillaMail session
email_address = session.get_session_state()[
'email_address'] #retrieves temp email address
payload = {
'email': email_address,
'queryName': 'testprot',
'input': 'seq',
'pdb': '1',
'.submit': 'continue',
'seq': seq
}
r = requests.post(
'http://www.compbio.dundee.ac.uk/jpred4/cgi-bin/jpred_form',
data=payload)
try: #try/catch in case a nucleotide/invalid sequence is entered
response = r.headers['Refresh'].split('?')
jobid = response[1]
joburl = 'http://www.compbio.dundee.ac.uk/jpred4/results/' + jobid + '/' + jobid + '.jnet'
page = requests.get(joburl).text
#No cancel
while page[0] == '<':
print("JpredSS Not Ready")
time.sleep(20)
page = requests.get(joburl).text
'''
#Cancel after 15 min
stime = time.time()
while page[0] == '<' or time.time() > stime + 900:
print("JpredSS Not Ready")
time.sleep(20)
page = requests.get(joburl).text
'''
if page[0] != '<':
raw = page.splitlines()
SS.pred = raw[1].replace('jnetpred:', '')
SS.pred = SS.pred.replace('-', 'C') #Replaces dashes with C
SS.pred = SS.pred.replace(',', '')
SS.conf = raw[2].replace('JNETCONF:', '')
SS.conf = SS.conf.replace(',', '')
SS.status = 1
print("JPred Complete")
else:
SS.pred += "JPred failed to respond in time"
SS.conf += "JPred failed to respond in time"
SS.status = 2 #error status
print("JPred failed: No response")
except:
SS.pred += "JPred failed: sequence not accepted"
SS.conf += "JPred failed: sequence not accepted"
SS.status = 4
print("JPred failed: sequence not accepted")
print("JPRED::")
print(SS.pred)
print(SS.conf)
return SS
from time import sleep
delay = 60
if len(sys.argv) < 2:
sys.stderr.write('usage: {} <account id> [delay]\n'.format(os.path.basename(sys.argv[0])))
sys.exit(1)
account = sys.argv[1]
if len(sys.argv) > 2:
delay = int(sys.argv[2])
print('checking guerillamail account {} every {} seconds (CTRL-C to quit)'.format(account, delay))
session = GuerrillaMailSession(email_address=account)
directory = 'email'
try:
os.makedirs(directory)
except OSError as exc:
if exc.errno == errno.EEXIST and os.path.isdir(directory):
pass
else: raise
while True:
sys.stdout.write('.')
sys.stdout.flush()
for item in session.get_email_list():
email = session.get_email(item.guid)
filename = 'email/{}.txt'.format(email.guid)
class GuerrillaMailApi:
"""
Api for using Guerrilla Mail.
"""
def __init__(self, user_name):
self.session = GuerrillaMailSession()
self.user_name = user_name
self.session.set_email_address(self.user_name)
self.user_email = self.session.get_session_state()['email_address']
def get_email_text(self, pattern):
"""
Get email text from GuerrillaMail server.
Checks the latest email from the inbox and searches for pattern in it.
If pattern is found then email's body is returned otherwise exception
is raised. Also, if latest email is not from MIT, it raises exception.
Checks GuerrillaMail server for email at the intervals of 5 seconds.
If the email is not found after 40 seconds then exception is raised.
Arguments:
pattern(str): Pattern to be found in the email's body.
Returns:
str: Email's body.
"""
email_text = ""
t_end = time.time() + TIME_OUT_LIMIT
# Run the loop for a pre defined time
time.sleep(INITIAL_WAIT_TIME)
while time.time() < t_end:
try:
# Check that mail box is not empty
email_list = self.session.get_email_list()
if not email_list:
# raise an exception that waits 3 seconds
# before restarting loop
raise MailException
# Get the email id of last email in the inbox
email_id = email_list[0].guid
# if last email is not sent by MIT raise the exception
email = self.session.get_email(email_id)
if email.sender != EMAIL_SENDER_ACCOUNT:
raise MailException
# Fetch the email text and stop the loop
email_text = email.body
if pattern not in email_text:
raise MailException
break
except MailException:
time.sleep(WAIT_TIME)
if email_text:
return email_text
raise MailException('No Email from ' + EMAIL_SENDER_ACCOUNT)
def get_url_from_email(self, matching_string):
"""
Connect to the email client
Get text of target email
fetch desired url from the email text
Args:
matching_string:
Returns:
target url:
"""
email_text = self.get_email_text(self.user_email)
return get_target_url_from_text(matching_string, email_text)
class GuerrillaMailApi(object):
"""
Api for using Guerrilla Mail.
"""
def __init__(self, user_name):
self.session = GuerrillaMailSession()
self.user_name = user_name
self.session.set_email_address(self.user_name)
self.user_email = self.session.get_session_state()['email_address']
def get_email_text(self, pattern):
"""
Get email text from GuerrillaMail server.
Checks the latest email from the inbox and searches for pattern in it.
If pattern is found then email's body is returned otherwise exception
is raised. Also, if latest email is not from MIT, it raises exception.
Checks GuerrillaMail server for email at the intervals of 5 seconds.
If the email is not found after 40 seconds then exception is raised.
Arguments:
pattern(str): Pattern to be found in the email's body.
Returns:
str: Email's body.
"""
email_text = ""
t_end = time.time() + TIME_OUT_LIMIT
# Run the loop for a pre defined time
time.sleep(INITIAL_WAIT_TIME)
while time.time() < t_end:
try:
# Check that mail box is not empty
email_list = self.session.get_email_list()
if not email_list:
# raise an exception that waits 3 seconds
# before restarting loop
raise MailException
# Get the email id of last email in the inbox
email_id = email_list[0].guid
# if last email is not sent by MIT raise the exception
email = self.session.get_email(email_id)
if email.sender != EMAIL_SENDER_ACCOUNT:
raise MailException
# Fetch the email text and stop the loop
email_text = email.body
if pattern not in email_text:
raise MailException
break
except MailException:
time.sleep(WAIT_TIME)
if email_text:
return email_text
else:
raise MailException('No Email from ' + EMAIL_SENDER_ACCOUNT)
def get_target_url_from_text(self, url_matching_string, text_chunk):
"""
Search and return the target url from text chunk, the url is searched
on the basis of partial string embedded in url
Args:
url_matching_string:
text_chunk:
Returns:
target url:
"""
pattern = r"(?P<url>http[s]?://[^\s\"]+(/{}/)[^\s\"]+)".format(
url_matching_string
)
regex_result = re.search(pattern, text_chunk)
if regex_result:
target_url = regex_result.group("url")
return target_url.rstrip('.')
else:
return 'Target URL not found in the text'
def get_url_from_email(self, matching_string):
"""
Connect to the email client
Get text of target email
fetch desired url from the email text
Args:
user_email:
matching_string:
Returns:
target url:
"""
email_text = self.get_email_text(
self.user_email
)
return self.get_target_url_from_text(matching_string, email_text)
def get(seq):
SS = ss.SS("RaptorX")
SS.status = 0
if (len(seq) < 27 or len(seq) > 4000): #<27 shouldnt happen with input validation
SS.pred += "Sequence is longer than 4000"
SS.conf += "Sequence is longer than 4000"
SS.status = 2 #error status
print("RaptorX failed: Sequence is shorter than 27 or longer than 4000")
'''
SS.pred += "Sequence is shorter than 27 or longer than 4000"
SS.conf += "Sequence is shorter than 27 or longer than 4000"
SS.status = 2 #error status
print("RaptorX failed: Sequence is shorter than 27 or longer than 4000")
'''
return SS #return SS so it will be readable as an ssObject
session = GuerrillaMailSession() #Creates GuerrillaMail session
email_address = session.get_session_state()['email_address'] #retrieves temp email address
payload = {'jobname': 'myprot',
'useProfile': 'true',
'predict_sub': 'Submit',
'email': email_address,
'sequences': seq}
r = requests.post('http://raptorx.uchicago.edu/StructurePropertyPred/predict/pred/', data=payload)
soup = BeautifulSoup(r.text,'html.parser')
try: #try/catch in case a nucleotide/invalid sequence is entered
url = soup.find(href=re.compile('http://raptorx.uchicago.edu/StructurePropertyPred/myjobs/')).get('href')
zipid = url.split('_')
zipid = zipid[1].replace('/','')
raw = requests.get(url).text
tree = html.fromstring(raw)
treelist = tree.xpath('//*[@id="content"]/center[1]/text()')
'''
#No cancel
while treelist != []:
print('RaptorX Not Ready')
time.sleep(20)
raw = requests.get(url).text
tree = html.fromstring(raw)
treelist = tree.xpath('//*[@id="content"]/center[1]/text()')
'''
#Cancel after 20 min
stime = time.time()
while treelist != [] or time.time() > stime + 1200:
print('RaptorX Not Ready')
time.sleep(20)
raw = requests.get(url).text
tree = html.fromstring(raw)
treelist = tree.xpath('//*[@id="content"]/center[1]/text()')
if treelist == []:
treelist = tree.xpath('//*[@id="infoval"]/script/text()')
zippath = 'http://raptorx.uchicago.edu/'
for word in treelist[0].split('"'):
if word[:30] == '/StructurePropertyPred/myjobs/':
zippath += word
zipss = requests.get(zippath)
while not zipss.ok:
time.sleep(20)
print('RaptorX Zip Not Ready')
#zipss = batchtools.requestWait(zippath, 'RaptorX Zip Not Ready')
mzip = request.urlopen(zippath)
z= bytes(mzip.read())
zf = ZipFile(io.BytesIO(z), "r")
ss3path = zipid + '/' + zipid + '.ss3.txt'
sslist = zf.read(ss3path).decode('utf-8').splitlines()[2:]
for i in range(len(sslist)):
word = sslist[i].split()
SS.pred += word[2]
SS.hconf.append(word[3])
SS.econf.append(word[4])
SS.cconf.append(word[5])
#SS.conf = "No conf given, Need formula to determine from h/e/c conf"
for i in range(len(SS.pred)):
if SS.pred[i] == 'C':
if SS.cconf[i] == "1.000":
SS.conf += '9' #puts in 9 if 100% confidence level
else:
SS.conf += SS.cconf[i][2] #puts in the 3rd character from the individual conf value string e.g. 8 if string is 0.873
if SS.pred[i] == 'E':
if SS.econf[i] == "1.000":
SS.conf += '9'
else:
SS.conf += SS.econf[i][2]
if SS.pred[i] == 'H':
if SS.hconf[i] == "1.000":
SS.conf += '9'
else:
SS.conf += SS.hconf[i][2]
SS.status = 1
print("RaptorX Complete")
else:
SS.pred += "failed to respond in time"
SS.conf += "failed to respond in time"
SS.status = 2 #error status
print("RaptorX failed: No response")
except:
SS.pred += "sequence not accepted"
SS.conf += "sequence not accepted"
SS.status = 4
print("RaptorX failed: sequence not accepted")
print("RAPTOR::")
print(SS.pred)
print(SS.conf)
return SS
def get(seq):
SS = ss.SS("Sable")
if len(seq) <= 12:
SS.status = 2
SS.pred += "Sequence is shorter than or equal to 12"
SS.conf += "Sequence is shorter than or equal to 12"
print("SABLE failed: Sequence is shorter than or equal to 12")
SS.status = 0
randName = batchtools.randBase62()
session = GuerrillaMailSession() #Creates GuerrillaMail session
email_address = session.get_session_state()['email_address'] #retrieves temp email address
payload = {'txtSeq': seq,
'seqName': randName,
'email': email_address,
'fileName':'',
'SS':'SS',
'version':'sable2',
'SAaction': 'wApproximator',
'SAvalue':'REAL'}
r = requests.post('http://sable.cchmc.org/cgi-bin/sable_server_July2003.cgi', data = payload)
#sable uses multiple emails to send results
query = 'from:(sable) subject:(sable result) query: ' + randName
#Length 4000 takes around 10 min
message = ''
stime = time.time()
email_id = False
#Waits indefinitely until results are out
email_id, message = batchtools.emailRequestWait(session, query, "Query:", randName, "Sable Not Ready", 30)
#Cancel in 15 min
#email_id, message = batchtools.emailRequestWait(session, query, "Query:", randName, "Sable Not Ready", 30, 900)
if email_id:
#message = emailtools.decodeEmail(email_service, email_id)
#print(message)
message_parts = message.splitlines()
#getting the prediction sequence and confidence
index = 0
while message_parts[index][:11] != 'END_SECTION':
if message_parts[index].startswith('>'):
SS.pred += message_parts[index + 2].strip()
SS.conf += message_parts[index + 3].strip()
index + 4 #add 4 then 1 later to get to next set of prediction
index += 1
#getting the probabilities for helix, beta strand, coil
index += 1 #go past the prediction's 'END_SECTION'
helixProb = ''
betaProb = ''
coilProb = ''
while message_parts[index][:11] != 'END_SECTION':
if message_parts[index].startswith('>'):
helixProb += message_parts[index + 2][3:].strip() + ' '
betaProb += message_parts[index + 3][3:].strip() + ' '
coilProb += message_parts[index + 4][3:].strip() + ' '
index += 1
SS.hconf = helixProb.split()
SS.econf = betaProb.split()
SS.cconf = coilProb.split()
SS.status = 1
print(SS.pred)
print(SS.conf)
print("Sable Complete")
else:
SS.pred += "Sable failed to respond in time"
SS.conf += "Sable failed to respond in time"
SS.status = 2 #error status
print("Sable failed: No response")
return SS
