Python commands.formfile函数代码示例

 def upload(self, input):
     self.get("/tool_runner/index?tool_id=upload1")
     tc.fv("1", "file_type", "bed")
     tc.fv("1", "dbkey", input.get('dbkey', '?'))
     tc.formfile("1", "file_data", input['file_path'])
     tc.submit("runtool_btn")
     tc.code(200)

    def test_image_processing_library_error(self):
        """
        If the image processing library errors while preparing a photo, report a
        helpful message to the user and log the error. The photo is not added
        to the user's profile.
        """
        # Get a copy of the error log.
        string_log = StringIO.StringIO()
        logger = logging.getLogger()
        my_log = logging.StreamHandler(string_log)
        logger.addHandler(my_log)
        logger.setLevel(logging.ERROR)

        self.login_with_twill()
        tc.go(make_twill_url('http://openhatch.org/people/paulproteus/'))
        tc.follow('photo')
        # This is a special image from issue166 that passes Django's image
        # validation tests but causes an exception during zlib decompression.
        tc.formfile('edit_photo', 'photo', photo('static/images/corrupted.png'))
        tc.submit()
        tc.code(200)

        self.assert_("Something went wrong while preparing this" in tc.show())
        p = Person.objects.get(user__username='paulproteus')
        self.assertFalse(p.photo.name)

        # an error message was logged during photo processing.
        self.assert_("zlib.error" in string_log.getvalue())
        logger.removeHandler(my_log)

 def upload_file(self, fname, ftype='auto', dbkey='hg17'):
     """Uploads a file"""
     fname = self.get_fname(fname)
     tc.go("./tool_runner/index?tool_id=upload1")
     tc.fv("1","file_type", ftype)
     tc.fv("1","dbkey", dbkey)
     tc.formfile("1","file_data", fname)
     tc.submit("runtool_btn")
     self.home()

 def test_set_avatar(self):
     self.login_with_twill()
     for image in (photo('static/sample-photo.png'),
                   photo('static/sample-photo.jpg')):
         url = 'http://openhatch.org/people/paulproteus/'
         tc.go(make_twill_url(url))
         tc.follow('photo')
         tc.formfile('edit_photo', 'photo', image)
         tc.submit()
         # Now check that the photo == what we uploaded
         p = Person.objects.get(user__username='paulproteus')
         self.assert_(p.photo.read() ==
                 open(image).read())

 def test_set_avatar_too_wide(self):
     self.login_with_twill()
     for image in [photo('static/images/too-wide.jpg'),
                   photo('static/images/too-wide.png')]:
         url = 'http://openhatch.org/people/paulproteus/'
         tc.go(make_twill_url(url))
         tc.follow('photo')
         tc.formfile('edit_photo', 'photo', image)
         tc.submit()
         # Now check that the photo is 200px wide
         p = Person.objects.get(user__username='paulproteus')
         image_as_stored = Image.open(p.photo.file)
         w, h = image_as_stored.size
         self.assertEqual(w, 200)

def annotate(params, proteins, \
             url="http://signalfind.org/tatfind.html", force=False):
    """
    Interfaces with the TatFind web service at (http://signalfind.org/tatfind.html)
    to predict if protein sequences contain Twin-Arginine Translocation (Tat)
    signal peptides.
    """
    # set the user-agent so web services can block us if they want ... :/
    python_version = sys.version.split()[0]
    agent("Python-urllib/%s (twill; inmembrane)" % python_version)

    outfn = 'tatfind.out'
    log_stderr("# TatFind(web) %s > %s" % (params['fasta'], outfn))

    if not force and os.path.isfile(outfn):
        log_stderr("# -> skipped: %s already exists" % outfn)
        fh = open(outfn, 'r')
        proteins = parse_tatfind_output(fh, proteins)
        fh.close()
        return proteins

    # dump extraneous output into this blackhole so we don't see it
    if not __DEBUG__: twill.set_output(StringIO.StringIO())

    go(url)
    if __DEBUG__: showforms()
    formfile("1", "seqFile", params["fasta"])
    submit()
    if __DEBUG__: show()

    tatfind_output = show()
    if __DEBUG__: log_stderr(tatfind_output)

    # write raw TatFind output to a file
    fh = open(outfn, 'w')
    fh.write(tatfind_output)
    fh.close()

    proteins = parse_tatfind_output(tatfind_output.split("\n"), proteins)

    return proteins

 def upload(self, file):
     self.get("/tool_runner/index?tool_id=upload1")
     tc.fv("1","file_type", "bed")
     tc.formfile("1","file_data", file)
     tc.submit("runtool_btn")
     tc.code(200)

def annotate(params, proteins, \
             url="http://rbf.bioinfo.tw/"+
                 "~sachen/OMPpredict/"+
                 "TMBETADISC-RBF-Content.html", force=False):
  """
  Interfaces with the TatFind web service at 
  (http://rbf.bioinfo.tw/~sachen/OMPpredict/TMBETADISC-RBF.php) 
  to predict if protein sequence is likely to be an outer membrane beta-barrel.
  
  Note that the default URL we use it different to the regular form used
  by web browsers, since we need to bypass some AJAX fun.
  """
  # TODO: automatically split large sets into multiple jobs
  #       since TMBETADISC seems to not like more than take 
  #       ~5000 seqs at a time
  if len(proteins) >= 5000:
    log_stderr("# ERROR: TMBETADISC-RBF(web): tends to fail with > ~5000 sequences.")
    return
  
  # set the user-agent so web services can block us if they want ... :/
  python_version = sys.version.split()[0]
  agent("Python-urllib/%s (twill; inmembrane)" % python_version)
  
  outfn = 'tmbetadisc-rbf.out'
  log_stderr("# TMBETADISC-RBF(web) %s > %s" % (params['fasta'], outfn))
  
  if not force and os.path.isfile(outfn):
    log_stderr("# -> skipped: %s already exists" % outfn)
    fh = open(outfn, 'r')
    proteins = parse_tmbetadisc_output(fh.read(), proteins)
    fh.close()
    return proteins
  
  # dump extraneous output into this blackhole so we don't see it
  if not __DEBUG__: twill.set_output(StringIO.StringIO())
  
  go(url)
  if __DEBUG__: showforms()
  formfile("1", "userfile", params["fasta"])
  fv("1", "format", "file")

  # set the user defined method
  method_map = {"aa":"Amino Acid Composition",
                "dp":"Depipetide Composition",
                "aadp":"Amino Acid & Depipetide Composition",
                "pssm":"PSSM"}
  if dict_get(params, 'tmbetadisc_rbf_method'):
    try:
      method = method_map[params['tmbetadisc_rbf_method']]
    except KeyError:
      log_stderr("# ERROR: Invalid setting from tmbetadisc_rbf_method. \
                    Must be set to aa, dp, aadp or pssm.")
      sys.exit()

  #fv("1", "select", "Amino Acid Composition")
  #fv("1", "select", "Depipetide Composition")
  #fv("1", "select", "Amino Acid & Depipetide Composition")
  #fv("1", "select", "PSSM")
  fv("1", "select", method)
  
  submit()
  
  waiting_page = show()
  if __DEBUG__: log_stderr(waiting_page)

  for l in waiting_page.split('\n'):
    if l.find("TMBETADISC-RBF-action.php?UniqueName=") != -1:
      result_url = l.split("'")[1]

  time.sleep(5)
  
  go(result_url)
  
  output = show()
  if __DEBUG__: log_stderr(output)
  
  # write raw output to a file
  fh = open(outfn, 'w')
  fh.write(output)
  fh.close()
  
  proteins = parse_tmbetadisc_output(output, proteins) 
  
  return proteins

def test():
    url = twilltestlib.get_url()
            
    # test empty page get_title
    namespaces.new_local_dict()
    twill.commands.reset_browser()
    browser = twill.get_browser()
    try:
        browser.get_title()
        assert 0, "should never get here"
    except BrowserStateError:
        pass

    ### now test a few special cases
    
    commands.go(url)
    commands.go('/login')
    commands.showforms()

    # test no matching forms
    try:
        commands.fv('2', 'submit', '1')
        assert 0
    except TwillAssertionError:
        pass

    # test regexp match
    commands.fv('1', '.*you', '1')


    # test ambiguous match to value
    commands.go('/testform')
    commands.fv('1', 'selecttest', 'val')
    commands.fv('1', 'selecttest', 'value1')
    commands.fv('1', 'selecttest', 'selvalue1')
    commands.formclear('1')
    try:
        commands.fv('1', 'selecttest', 'value')
        assert 0
    except ClientForm.ItemNotFoundError:
        pass

    # test ambiguous match to name
    commands.go('/testform')
    try:
        commands.fv('1', 'item_', 'value')
        assert 0
    except Exception:
        pass

    try:
        commands.formfile('1', 'selecttest', 'null')
        assert 0
    except Exception:
        pass

    commands.go('http://www.google.com/')
    browser.get_title()

    # test the twill script.
    twilltestlib.execute_twill_script('test-form.twill', initial_url=url)

def upload_list(browser, pagename, uploads):

    # get the file sizes for later comparison.
    filesizes = []
    for fn in uploads:
        filesizes.append(os.stat(fn)[stat.ST_SIZE])
    filesizes.reverse()  # because they get listed newest first.

    # Upload copy #1.
    t.go(host + "index.php/Special:Upload")
    t.formfile("1", "wpUploadFile", uploads[0])
    t.fv("1", "wpDestFile", pagename)
    t.fv("1", "wpUploadDescription", "Uploading %s" % pagename)
    t.submit("wpUpload")

    # Verify that we succeeded.
    t.find("File:%s" % pagename)

    for fn in uploads[1:]:
        # propose that we upload a replacement
        t.go(host + "index.php?title=Special:Upload&wpDestFile=%s&wpForReUpload=1" % pagename)
        t.formfile("1", "wpUploadFile", fn)
        t.fv("1", "wpUploadDescription", "Uploading %s as %s" % (fn, pagename))
        t.submit("wpUpload")

    # get the URLs for the thumbnails
    urls = []
    for url in re.finditer(
        r'<td><a href="([^"]*?)"><img alt="Thumbnail for version .*?" src="(.*?)"', browser.get_html()
    ):
        urls.append(url.group(1))
        urls.append(url.group(2))

    print filesizes
    for i, url in enumerate(urls):
        t.go(url)
        if i % 2 == 0 and len(browser.get_html()) != filesizes[i / 2]:
            print i, len(browser.get_html()), filesizes[i / 2]
            t.find("Files differ in size")
        t.code("200")
        t.back()

    # delete all versions
    t.go(host + "index.php?title=File:%s&action=delete" % pagename)
    # after we get the confirmation page, commit to the action.
    t.fv("1", "wpReason", "Test Deleting...")
    t.submit("mw-filedelete-submit")

    # make sure that we can't visit their URLs.
    for i, url in enumerate(urls):
        t.go(url)
        if 0 and i % 2 == 1 and i > 0 and browser.get_code() == 200:
            # bug 30192: the archived file's thumbnail doesn't get deleted.
            print "special-casing the last URL"
            continue
        t.code("404")

    # restore the current and archived version.
    t.go(host + "index.php/Special:Undelete/File:%s" % pagename)
    t.fv("1", "wpComment", "Test Restore")
    t.submit("restore")

    # visit the page to make sure that the thumbs get re-rendered properly.
    # when we get the 404 handler working correctly, this won't be needed.
    t.go(host + "index.php?title=File:%s" % pagename)

    # make sure that they got restored correctly.
    for i, url in enumerate(urls):
        t.go(url)
        if i % 2 == 0 and len(browser.get_html()) != filesizes[i / 2]:
            t.find("Files differ in size")
        t.code("200")
        t.back()

    if len(uploads) != 2:
        return

    match = re.search(r'"([^"]+?)" title="[^"]+?">revert', browser.get_html())
    if not match:
        t.find("revert")
    t.go(match.group(1).replace("&amp;", "&"))

    def test_data_uploads(self):  
        # data upload test
        name = 'Upload-test-name'
        self.create_project(name)
        
        tc.follow(name)

        # find the project id
        url = tc.follow('Edit')
        pid = url.split("/")[-2]
        tc.go("/data/upload/simple/%s/" % pid)
        
        # search for then add Demo User to this project
        tc.formfile("1", "File1", conf.testdata('short-data.bed') )
        tc.formfile("1", "File2", conf.testdata('short-good-input.gtrack') )
        tc.formfile("1", "File3", conf.testdata('readcounts.png') )
        tc.submit()

        # verify uploads
        tc.find("short-data.bed")
        tc.find("short-good-input.gtrack")
        tc.find("readcounts.png")

        # visit the dataset            
        tc.follow("short-good-input.gtrack")
        tc.find("waiting")

        # edit the dataset
        tc.follow("Edit")
        tc.fv("1", "name", "short-good-input.gtrack" )
        tc.fv("1", "info","extra-info" )
        tc.submit()
        tc.find("extra-info")

        # upload two results for it
        tc.follow("Add results")
        tc.formfile("1", "content", conf.testdata('short-data.bed') )
        tc.formfile("1", "image", conf.testdata('readcounts.png') )
        tc.submit()
        tc.follow("short-data.bed")
        tc.back()

        # upload one image
        tc.follow("Add results")
        tc.formfile("1", "image", conf.testdata('shift.png') )
        tc.submit()
        tc.follow("shift.png")
        tc.back()

        # back to project view
        tc.follow("Project view")
        self.delete_project(name)

def annotate(params, proteins, \
             url="http://services.cbu.uib.no/tools/bomp/", force=False):
    """
    Uses the BOMP web service (http://services.cbu.uib.no/tools/bomp/) to
    predict if proteins are outer membrane beta-barrels.
    """
    # set the user-agent so web services can block us if they want ... :/
    python_version = sys.version.split()[0]
    agent("Python-urllib/%s (twill; inmembrane/%s)" %
          (python_version, inmembrane.__version__))

    bomp_out = 'bomp.out'
    log_stderr("# BOMP(web) %s > %s" % (params['fasta'], bomp_out))

    if not force and os.path.isfile(bomp_out):
        log_stderr("# -> skipped: %s already exists" % bomp_out)
        bomp_categories = {}
        fh = open(bomp_out, 'r')
        for l in fh:
            words = l.split()
            bomp_category = int(words[-1:][0])
            seqid = parse_fasta_header(l)[0]
            proteins[seqid]['bomp'] = bomp_category
            bomp_categories[seqid] = bomp_category
        fh.close()
        return bomp_categories

    # dump extraneous output into this blackhole so we don't see it
    if not __DEBUG__: twill.set_output(StringIO.StringIO())

    go(url)
    if __DEBUG__: showforms()
    formfile("1", "queryfile", params["fasta"])
    submit()
    if __DEBUG__: show()

    # extract the job id from the page
    links = showlinks()
    job_id = None
    for l in links:
        if l.url.find("viewOutput") != -1:
            # grab job id from "viewOutput?id=16745338"
            job_id = int(l.url.split("=")[1])

    if __DEBUG__: log_stderr("BOMP job id: %d" % job_id)

    if not job_id:
        # something went wrong
        log_stderr("# BOMP error: Can't find job id")
        return

    # parse the HTML table and extract categories
    go("viewOutput?id=%i" % (job_id))

    polltime = 10
    log_stderr("# Waiting for BOMP to finish .")
    while True:
        try:
            find("Not finished")
            log_stderr(".")
        except:
            # Finished ! Pull down the result page.
            log_stderr(". done!\n")
            go("viewOutput?id=%i" % (job_id))
            if __DEBUG__: log_stderr(show())
            break

        # Not finished. We keep polling for a time until
        # we give up
        time.sleep(polltime)
        polltime = polltime * 2
        if polltime >= 7200:  # 2 hours
            log_stderr("# BOMP error: Taking too long.")
            return
        go("viewOutput?id=%i" % (job_id))
        if __DEBUG__: log_stderr(show())

    bomp_html = show()
    if __DEBUG__: log_stderr(bomp_html)

    # Results are in the only <table> on this page, formatted like:
    # <tr><th>gi|107836852|gb|ABF84721.1<th>5</tr>
    soup = BeautifulSoup(bomp_html)
    bomp_categories = {}  # dictionary of {name, category} pairs
    for tr in soup.findAll('tr')[1:]:
        n, c = tr.findAll('th')
        name = parse_fasta_header(n.text.strip())[0]
        category = int(c.text)
        bomp_categories[name] = category

    # write BOMP results to a tab delimited file
    fh = open(bomp_out, 'w')
    for k, v in bomp_categories.iteritems():
        fh.write("%s\t%i\n" % (k, v))
    fh.close()

    if __DEBUG__: log_stderr(str(bomp_categories))

    # label proteins with bomp classification (int) or False
    for name in proteins:
#.........这里部分代码省略.........