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']
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)
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