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

def download():
    url = read_file(FILE_GDOC).strip()
    print("loading %s" % url)
    sheet = load_url(url)
    phenos = read_csv(StringIO(sheet))
    sel = phenos[phenos["malformation?"] == "y"]["phenotype"]
    sel.to_csv(FILE_SELECTION, index=False)
    print("got %d selected phenotypes out of %d, stored in %s" %
          len(sel), len(phenos), FILE_SELECTION)

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

    def __init__(self, filename, data=None):
        self.filename = filename
        self.shortname = os.path.basename(filename)
        self.certs = None
        if not data:
            img3 = read_file(filename)
        else:
            img3 = data
        self.img3 = img3
        self.ecidoffset = 0
        
        if img3[0:4] != '3gmI':
            print "Magic 3gmI not found in " + filename
            return

        fullSize = dword(img3, 4)
        sizeNoPack = dword(img3, 8)
        sigCheckArea = dword(img3, 12)

        self.sha1 = hashlib.sha1(img3)
        self.fileHash = hashlib.sha1(img3[12:20+sigCheckArea])

        i = 20
      
        sections = {}

        while i < fullSize:
            tag = img3[i:i+4][::-1] #reverse fourcc tag
            total_length = dword(img3, i+4)
            data_length = dword(img3, i+8)

            if tag == "DATA":
                self.datalen = data_length
                data = img3[i+12:i+total_length]
            else:
                data = img3[i+12:i+12+data_length]
                
            if tag in Img3.INT_FIELDS:
                data = struct.unpack("<L", data)[0]
            elif tag == "VERS":
                data = data[4:]
            elif tag == "TYPE":
                data = data[::-1]
            elif tag == "ECID":
                self.ecidoffset = i
            #print "%s offset=%x len=%x" % (tag,i, data_length)
            if tag != "KBAG" or dword(data,0) == 1:
                sections[tag] = data

            i += total_length

        self.sections = sections
        self.leaf_cert = None
        self.sig = None
        self.key = ""
        self.iv = ""
        self.extractCertificates()

 def _get_meta(self,name,link):
     # load meta from disk or download it (slow for each serie, thatwhy we cache it)
     local = self.tmp_dir
     if not os.path.exists(local):
         os.makedirs(local)
     m = md5.new()
     m.update(name)
     image = os.path.join(local,m.hexdigest()+'_img.url')
     plot = os.path.join(local,m.hexdigest()+'_plot.txt')
     if not os.path.exists(image):
         data = util.request(link)
         data = util.substr(data,'<div id=\"archive-posts\"','</div>')
         m = re.search('<a(.+?)href=\"(?P<url>[^\"]+)', data, re.IGNORECASE | re.DOTALL)
         if not m == None:
             data = util.request(m.group('url'))
             self._get_image(data,image)
             self._get_plot(data,plot)
     return util.read_file(image).strip(),util.read_file(plot)

    def download_stats(self):
        url = self.url + '/data/stats'
        path = self.info_folder + '/stats.html'
        util.download(url, path, self.cookie_file)

        content = util.read_file(path)
        pattern = r'<h1.*?</table>'
        content = re.search(pattern, content, re.DOTALL).group(0)
        util.write_file(path, content)