Python util.read_file函数代码示例

    def _complete_path(self, item):

        c = re.compile(r"(%s)_(\d+)\.(\w+)" %
                       ("|".join(self.SUPPORTED_METHODS)))

        url_path = UrlPath(get_url_path(item[0][len(self.api_dir):]))

        for current_file in sorted(item[2]):
            m = c.match(current_file)
            if m is None:
                continue
            method, status_code, format = m.groups()

            if method in url_path.resources:
                url_path.resources[method].files.append(
                    ResourceFormatFile(
                        status_code,
                        format,
                        read_file("%s/%s" % (item[0], current_file))))
            else:
                resource = self._create_resource(
                    item[0], method, url_path.path)

                resource.files.append(
                    ResourceFormatFile(
                        status_code,
                        format,
                        read_file("%s/%s" % (item[0], current_file))))

                # add resource to url_path
                url_path.resources[method] = resource

        return url_path

def save_user_sim_matrix(topics):
  for i in range(60):
    topic_path = 'user_similarity/user_topic_sim/'+str(topics)+'_topics/'+str(i)+".pickle"
    tag_path = 'user_similarity/user_tag_sim/'+str(i)+".pickle"
    topic_i = util.read_file(topic_path)
    tag_i = util.read_file(tag_path)
    for t in topic_i:
      topic_i[t] = topic_i[t]*tag_i[t]
    path = 'user_similarity/user_sim/'+str(topics)+'_hybrid/'+str(i)+".pickle"
    util.write_file(topic_i,path)

def importData():
    # read data and split training data into training and validation sets
    data_train, labels_train = read_file('training')
        
    #assert len(data_train[0]) == len(labels_train[0])
    #assert len(data_train[200]) == len(labels_train[200])

    data_test, labels_test = read_file('test')
            
    #assert len(data_test[0]) == len(data_test[0])
    #assert len(data_test[200]) == len(data_test[200])
    
    return data_train, data_test, labels_train, labels_test

def _find_files(url, folder, cookie):
    """
    Recursively find all files in current page.
    :param url: A URL to given page.
    :param folder: A destination folder for this page.
    :param cookie: A cookie file used for downloading.
    :return: A list of files (URL, path) in current page.
    """
    files = []

    path = '{}/temp.html'.format(folder)
    util.download(url, path, cookie)

    page = util.read_file(path)
    util.remove(path)

    # recursively find all files in sub-folders
    pattern = r'<tr><td colspan="4"><a href="(.*?)">(.*?)</a>'
    for find in re.finditer(pattern, page, re.DOTALL):
        url = find.group(1)
        sub_folder = '{}/{}'.format(folder, find.group(2))
        files += _find_files(url, sub_folder, cookie)

    # find all files in this page
    pattern = r'<tr><td>(.*?)</td>.*?Embed.*?<a href="(.*?)\?.*?">Download</a>'
    for find in re.finditer(pattern, page, re.DOTALL):
        url = find.group(2)
        file_name = find.group(1)
        path = u'{}/{}'.format(folder, file_name)
        files.append((url, path))

    return files

def run_test(self, name, path, num_cores, args=[]):
    """ 
    Run a single test.
    """
    try:

        # Compile the program
        (exit, output) = call([COMPILE, path+'/'+name+'.sire'] 
                + ['-t', 'mpi', '-n', '{}'.format(num_cores)] + args)
        self.assertTrue(exit)

        # Simulate execution
        (exit, output) = call([SIMULATE, '-np', '{}'.format(num_cores), 'a.out'] 
                + SIM_FLAGS)
        self.assertTrue(exit)
    
        # Check the output against the .output file
        self.assertEqual(output.strip(), 
                read_file(path+'/'+name+'.output').strip())
    
    except Exception as e:
        sys.stderr.write('Error: {}\n'.format(e))
        raise
    
    except:
        sys.stderr.write("Unexpected error: {}\n".format(sys.exc_info()[0]))
        raise

	def render(self):
		path = self.model["filename"]
		filename = os.path.basename(path)

		self.headers["Content-Disposition"] = "inline; filename=%s" % (filename)

		return util.read_file(path)

def regenerate(in_dir):
    os.umask(022)

    global settings
    settings = util.parse_headers(util.read_file(
            os.path.join(in_dir, 'settings')).strip())

    global jinja
    jinja = jinja2.Environment(
        loader=jinja2.FileSystemLoader(os.path.join(in_dir, 'templates')),
        autoescape=True)

    posts = load_posts(os.path.join(in_dir, 'posts'))

    util.write_if_changed('index.html', generate_frontpage(posts))
    if len(posts) > FRONTPAGE_POSTS:
        util.write_if_changed('archive.html', generate_archive(posts))
    util.write_if_changed('atom.xml', generate_feed(posts))

    for post in posts:
        dir = os.path.split(post.path)[0]
        try:
            os.makedirs(dir)
        except OSError:
            pass
        root = '../' * post.path.count('/')
        util.write_if_changed(post.path,
                              generate_post_page(root, post).encode('utf-8'))

def get_user_sim_matrix(topics):
  matrix = {}
  for i in range(60):
    path = 'user_similarity/user_sim/'+str(topics)+'_hybrid/'+str(i)+".pickle"
    matrix.update(util.read_file(path))
    print i
  return matrix

def hill_climb(init_tour):
    cur_iterator = 0
    max_iterator = 100
    min_distance = 100000;

    best_tour = init_tour

    while cur_iterator < max_iterator:
        flag = False
        for newtour in swap_cities(init_tour):
            if cur_iterator > max_iterator:
                break
            cur_iterator += 1
            distance = util.get_path_distance(newtour, util.read_file())
            if distance < min_distance:
                best_tour = newtour
                min_distance = distance
                flag = True
                break
        if flag == False:
            break

        #print best_tour
        #print min_distance
        #print cur_iterator

    return best_tour, min_distance

def get_tag_sim_matrix():
  matrix = {}
  for i in range(60):
    path = 'user_similarity/user_tag_sim/genres/'+str(i)+".pickle"
    matrix.update(util.read_file(path))
    print i
  return matrix

def main():
    g = u.read_file("../data/NewYorkOneWeek.txt")
    results = iterative_removing_algorithm(g,5)
    print 'done'
    for r in results:
        nx.draw_networkx(r)
        plt.show()

def download(course, item):
    """
    Download announcement JSON.
    :param course: A Course object.
    :param item: {
        "close_time": 2147483647,
        "user_id": 1069689,
        "open_time": 1411654451,
        "title": "Coursera",
        "deleted": 0,
        "email_announcements": "email_sent",
        "section_id": "14",
        "order": "6",
        "item_type": "announcement",
        "__type": "announcement",
        "published": 1,
        "item_id": "39",
        "message": "Hello, everyone.",
        "uid": "announcement39",
        "id": 39,
        "icon": ""
    }
    :return: None.
    """
    path = '{}/announcement/{}.json'
    path = path.format(course.get_folder(), item['item_id'])

    util.make_folder(path, True)
    util.write_json(path, item)

    content = util.read_file(path)
    content = util.remove_coursera_bad_formats(content)

    util.write_file(path, content)

def main():
    args = process_command_line_arguments()
    util.mkdir(PATH['TIMBRADAS'])

    xml = util.read_file(args.factura)

    # Enviamos a timbrar con el PAC
    timbra_xml(xml)
    return

	def test_dev(self, infile, outfile):
		sent_iter = read_file(infile)
		handle = open(outfile, 'w', encoding='utf-8')
		for sent in sent_iter:
			predict_sentence = self.predict(convert_to_no_EC(sent))
			for item in predict_sentence:
				handle.write('{0}\t{1}\n'.format(item[0], item[1]))
			handle.write('\n')
		handle.close()

def load_wordlist(filename):
    """ 
    This function should return a list or set of words from the given filename.
    """
    words = set()
    for str in util.read_file(filename):
        words.add(str)

    return words