Exemple #1
0
def main(indexer_token, indexer_URL, manifestPath, outputXesPath):
    theIndexer = indexer.IndexerClient(indexer_token,
                                       indexer_URL,
                                       headers={'User-Agent': '?'})

    extract(theIndexer, manifestPath, outputXesPath)
    sys.exit(0)
Exemple #2
0
def plotBelos(files=None, leg=None):
    if files is None:
        files = ['./Picard.txt']
    i = 0
    for file_str in files:
        lin_iter = ex.extract(file_str, ex.BelosMaxItPattern)
        linatol = ex.extract(file_str, ex.BelosArTolPattern)
        print(linatol)
        pl.figure(4)
        if isinstance(lin_iter, float):  # wtf
            lin_iter = [lin_iter]
        pl.plot(range(1, len(lin_iter) + 1), lin_iter, marker='.')
        pl.xlabel('Picard iteration')
        pl.ylabel(r'linear iterations')
        pl.ylabel(r'linear iterations', ha='left', va='bottom', rotation=0)
        pl.gca().yaxis.set_label_coords(-0.08, 1.02)
        if leg is not None:
            pl.legend(leg, loc=0)
        pl.gca().get_xaxis().set_major_locator(pl.MaxNLocator(integer=True))
        pl.savefig('liniter.pdf', bbox_inches='tight')
        #
        pl.figure(5)
        pl.semilogy(range(1, len(linatol) + 1), linatol, marker='.')
        pl.xlabel('Picard iteration')
        pl.ylabel(r'archieved tolerance of the linear solver')
        pl.ylabel(r'archieved tolerance of the linear solver',
                  ha='left',
                  va='bottom',
                  rotation=0)
        pl.gca().yaxis.set_label_coords(-0.08, 1.02)
        # legend(leg,bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
        if leg is not None:
            pl.legend(leg, loc=0)
        pl.gca().get_xaxis().set_major_locator(pl.MaxNLocator(integer=True))
Exemple #3
0
def plotNOX(paths=None, filename='output', run='', newton=False, save=False):
    """ plots residual ... over iterations (deprecated) """
    if paths is None:
        paths = ['./']
    for path in paths:
        iter_count = ex.extract(path + filename + str(run), ex.NOXIterPattern)
        res = ex.extract(path + filename + str(run), ex.NOXResPattern)
        # dof = ex.extract(path+filename+str(run), ex.PimpDofPattern)[0][0]
        # print('dof: ', dof)
        print(iter_count)
        print(res)
        pl.figure(1)
        # pl.semilogy(iter_count, res[:, 0]/pl.sqrt(dof))
        # pl.semilogy(res[:, 0]/pl.sqrt(dof), marker='.')
        pl.semilogy(res[:, 0], marker='.')
        if newton:
            pl.xlabel('Newton step')
        else:
            pl.xlabel('Picard iteration')
        pl.ylabel(r'$||\mathbf{r}||_2/\sqrt{N}$')
        # pl.ylabel(r'$||\mathbf{r}||_2/\sqrt{N}$', ha='left', va='bottom',
        # rotation=0)
        # pl.gca().yaxis.set_label_coords(-0.08, 1.02)
        pl.gca().get_xaxis().set_major_locator(pl.MaxNLocator(integer=True))
        if save:
            pl.savefig('F.pdf', bbox_inches='tight')
        pl.figure(2)
        pl.semilogy(iter_count[1:], res[1:, 1], basey=2, marker='.')
        if newton:
            pl.xlabel('Newton step')
        else:
            pl.xlabel('Picard iteration')
        pl.ylabel(r'step width')
        # pl.ylabel(r'step width', ha='left', va='bottom', rotation=0)
        # pl.gca().yaxis.set_label_coords(-0.08, 1.02)
        pl.gca().get_xaxis().set_major_locator(pl.MaxNLocator(integer=True))
        if save:
            pl.savefig('lam.pdf', bbox_inches='tight')
        #
        pl.figure(3)
        # pl.semilogy(iter_count[1:], res[1:, 2]/pl.sqrt(dof), marker='.')
        pl.semilogy(iter_count[1:], res[1:, 2], marker='.')
        if newton:
            pl.xlabel('Newton step')
        else:
            pl.xlabel('Picard step')
        pl.ylabel(r'$||\delta\mathbf{q}||_2/\sqrt{N}$')
        pl.gca().yaxis.set_label_coords(-0.08, 1.02)
        pl.gca().get_xaxis().set_major_locator(pl.MaxNLocator(integer=True))
        if save:
            pl.savefig('du.pdf', bbox_inches='tight')
Exemple #4
0
def main():
    if not os.path.exists(os.path.expanduser('~/.bpkg')):
        os.mkdir(os.path.expanduser('~/.bpkg'))

    if len(sys.argv) == 1:
        print('Error: No arguments present.')
        os.system('python bpkg.py -h')
        exit()

    # Change this each time version changes
    if sys.argv[1] == '-v':
        print('bpkg application packaging utility version 1.0.0')
        exit()

    if sys.argv[1] == '-h':
        print('''
bpkg syntax - bpkg [-h|-v|start|bundle|extract|cleanup] foldername

bpkg is a tool used to bundle applications.

    cleanup - Cleans up the bpkg cache
    start - This command is used to start the application.
    bundle - This command is used to bundle an application hence the name.
    extract - This command is used to extract the contents of an application from its bundle.
            ''')
        exit()

    if not sys.argv[1] == 'cleanup':
        if sys.argv[2] == None:
            print(
                'The directory of the project you want to package should be the second argument'
            )

    if sys.argv[1] == 'start':
        start_app(sys.argv[2])
    elif sys.argv[1] == 'cleanup':
        for root, dirs, files in os.walk(os.path.expanduser('~/.bpkg')):
            for f in files:
                os.unlink(os.path.join(root, f))
            for d in dirs:
                shutil.rmtree(os.path.join(root, d))
    elif sys.argv[1] == 'bundle':
        bundle(sys.argv[2])
    elif sys.argv[1] == 'extract':
        extract(sys.argv[2])
    else:
        print(
            'bundle, start, cleanup or extract should be present as the second argument'
        )
        exit()
Exemple #5
0
    def read(self, fname):
        if os.path.exists(self.path+fname):
            return cPickle.load(open(self.path+fname, 'rb'))

        dt = {'images':[], 'landmarks':[], 'aus':[], 'subjects':[], 'sequences':[]}

        # Get directory structure
        subjects = sorted([f for f in os.listdir(self.path_im)])
        sequences = [sorted(os.listdir(self.path_im+sub+'/')) for sub in subjects]

        print('###### READING PAIN DATASET ######')
        for subject, subject_sequences in zip(subjects, sequences):
            for sequence in subject_sequences:
                print('Subject:{}, Sequence:{}'.format(subject,sequence))
                rpath = subject+'/'+sequence + '/'

                im_seq = read_folder(self.path_im+rpath)
                lm_seq = np.asarray(read_folder(self.path_lm+rpath), dtype=np.float16)[:,:,::-1]

                # Extract face and resize
                S = map(list, zip(*[extract(i,l,1,30) for i,l in zip(im_seq, lm_seq)]))

                dt['images'].append(S[0])
                dt['landmarks'].append(S[1])
                dt['aus'].append(read_folder(self.path_au+rpath))
                dt['subject'].append(subject)
                dt['sequence'].append(sequence)

        cPickle.dump(dt, open(self.path+fname, 'wb'), cPickle.HIGHEST_PROTOCOL)

        return dt
def save_extractor_case(doi, is_biorxiv):
    r = extract(doi, is_biorxiv, False, False)
    r['date'] = r['date'].strftime('%Y-%m-%d')
    r['image_dir'] = os.listdir(r['image_dir'])
    open('test/extract_test_cases/{}.json'.format(doi.replace('/', '_')),
         'w',
         encoding='utf-8').write(json.dumps(r))
Exemple #7
0
def load_text(file_name):
    '''
    loads text from specific folder on the filing system.


      Parameters
    ----------
    file_name: str
        the name of the folder containing the texts

    Returns
    ----------
    total_text : list
        list of raw texts from each document.
    file_names : list
        list of file names.

    '''
    total_text = []
    file_names = []

    path = 'uploads/extracted/' + str(file_name)

    for filename in os.listdir(path):
        text, tokens, keywords = extract(os.path.join(path, filename))
        total_text.append(text)
        file_names.append(filename)

    return total_text, file_names
Exemple #8
0
def make_page_features(pages: np.ndarray) -> pd.DataFrame:
    """
    Calculates page features (site, country, agent, etc) from urls
    :param pages: Source urls
    :return: DataFrame with features as columns and urls as index
    """
    tagged = extractor.extract(pages).set_index('page')
    # Drop useless features为何将标题列也删除?
    features: pd.DataFrame = tagged.drop(['term', 'marker'], axis=1)
    # todo
    #  tagged=                                                                    agent  ... marker
    #  page                                                                       ...
    #  !vote_en.wikipedia.org_all-access_all-agents        all-access_all-agents  ...    NaN
    #  !vote_en.wikipedia.org_all-access_spider                all-access_spider  ...    NaN
    #  !vote_en.wikipedia.org_desktop_all-agents              desktop_all-agents  ...    NaN
    #  ...                                                                   ...  ...    ...
    #  [Alexandros]_ja.wikipedia.org_all-access_all-ag...  all-access_all-agents  ...    NaN
    #  [Alexandros]_ja.wikipedia.org_all-access_spider         all-access_spider  ...    NaN
    #  [Alexandros]_ja.wikipedia.org_desktop_all-agents       desktop_all-agents  ...    NaN
    #  [Alexandros]_ja.wikipedia.org_mobile-web_all-ag...  mobile-web_all-agents  ...    NaN
    #  [145036 rows x 5 columns];(145036, 5);
    #  &
    #  features=                                                                    agent                   site country
    #  page
    #  !vote_en.wikipedia.org_all-access_all-agents        all-access_all-agents          wikipedia.org      en
    #  !vote_en.wikipedia.org_all-access_spider                all-access_spider          wikipedia.org      en
    #  !vote_en.wikipedia.org_desktop_all-agents              desktop_all-agents          wikipedia.org      en
    #  ...                                                                   ...                    ...     ...
    #  [Alexandros]_ja.wikipedia.org_all-access_all-ag...  all-access_all-agents          wikipedia.org      ja
    #  [Alexandros]_ja.wikipedia.org_all-access_spider         all-access_spider          wikipedia.org      ja
    #  [Alexandros]_ja.wikipedia.org_desktop_all-agents       desktop_all-agents          wikipedia.org      ja
    #  [Alexandros]_ja.wikipedia.org_mobile-web_all-ag...  mobile-web_all-agents          wikipedia.org      ja
    #  [145036 rows x 3 columns];(145036, 3)
    # print(f"tagged={tagged};{tagged.shape}; features={features};{features.shape}")
    return features
Exemple #9
0
def polt_speedup(paths, nps, lab=None, runs=None):
    """ plots speedup """
    if lab is None:
        lab = []
    if runs is None:
        runs = ['']
    time = []
    for path in paths:
        temptime = 1e99
        for run in runs:
            tempnew = ex.extract(path + 'output' + str(run),
                                 ex.PimpSolveTimePattern,
                                 isarray=False)
            print('tempnew: ', tempnew)
            tempnew = tempnew
            temptime = min(temptime, tempnew)
        time.append(temptime)
    #
    print('nps: ', nps)
    print('time: ', time)
    if not lab:
        pl.plot(nps, time[0] / pl.array(time), '.-', ms=5)
    else:
        pl.plot(nps, time[0] / pl.array(time), '.-', ms=5, label=lab)
    pl.plot(nps, pl.array(nps) / pl.array(nps[0]), ':', lw=2)
    pl.ylim(ymin=1)
    pl.gca().xaxis.set_ticks(nps)
    pl.xlabel('number of cores')
    pl.ylabel('speed-up', ha='left', va='bottom', rotation=0)
    pl.gca().yaxis.set_label_coords(-0.05, 1.075)
    pl.gca().yaxis.set_label_coords(-0.08, 1.02)
Exemple #10
0
def analyze(ref=''):
    """ analyze """
    #
    files = [
        'Picard' + ref + '.txt', 'MHDtConvectionDiffusion' + ref + '.txt',
        'DivGrad' + ref + '.txt',
        'ModeNonlinearOp_ConvectionDiffusionVOp' + ref + '.txt',
        'ConvectionDiffusionVOp' + ref + '.txt'
    ]
    #
    for fil in files:
        stats = ex.extract(fil, ex.BelosIterPattern)
        count = len(stats[:, 0])
        print(fil, ' (', count, ')')
        if count != 0:
            print('total: ', sum(stats[:, 0]))
            print('iter: ', np.percentile(stats[:, 0], 10),
                  np.percentile(stats[:, 0], 50),
                  np.percentile(stats[:, 0], 90))
            print('iter: ', np.mean(stats[:, 0]), '+- ', np.std(stats[:, 0]))
            print('max: ', np.max(stats[:, 0]))
            print('tol: ', np.percentile(stats[:, 1], 10),
                  np.percentile(stats[:, 1], 50),
                  np.percentile(stats[:, 1], 90))
            print('tol: ', np.mean(stats[:, 1]), '+- ', np.std(stats[:, 1]))
        print()
def synchronize():
    arr = extract()
    plantgoed = arr[0]
    verkoopbare = arr[1]
    coniferen = arr[2]
    
    db = MySQLdb.connect(host="188.241.112.113", user="******", passwd="brecht123", db="kapelhof")
    cursor = db.cursor()
    
    #clear the table:
    cursor.execute("TRUNCATE TABLE voorraad2;")
    
    #plantgoed:
    for i in xrange(len(plantgoed)):
        cursor.execute("INSERT INTO voorraad2(Beschrijving, Prijs, Voorradig, Plantgoed, Id) VALUES(%s, %s, %s, %s, %s)",
                   (plantgoed[i]['beschrijving'], plantgoed[i]['prijs'], plantgoed[i]['aantal'], 1, plantgoed[i]['id']) )
    
    #verkoopbare:
    for i in xrange(len(verkoopbare)):
        cursor.execute("INSERT INTO voorraad2(Beschrijving, Prijs, Voorradig, Plantgoed, Id) VALUES(%s, %s, %s, %s, %s)",
                   (verkoopbare[i]['beschrijving'], verkoopbare[i]['prijs'], verkoopbare[i]['aantal'], 0, verkoopbare[i]['id']))
    
    #coniferen:
    for i in xrange(len(coniferen)):
        cursor.execute("INSERT INTO voorraad2(Beschrijving, Prijs, Voorradig, Plantgoed, Id) VALUES(%s, %s, %s, %s, %s)",
                   (coniferen[i]['beschrijving'], coniferen[i]['prijs'], coniferen[i]['aantal'], 0, coniferen[i]['id']))
        
    db.commit()
    
    return True
Exemple #12
0
def order_phrases(extraction_file):
    phrases = extract(extraction_file)
    characters = {}
    dialogues = []

    for phrase in phrases:
        if phrase.startswith("SCENE") or phrase.startswith(
                "ACT") or "END" in phrase:
            continue

        character_name = get_character_name(phrase)

        if character_name is not None:
            character_name = character_name.title()

            character_phrase = nltk.sent_tokenize(phrase)[1:]

            if character_name not in characters:
                gender = input("Which gender is %s? (male/female): " %
                               character_name)
                characters[character_name] = gender

            dialogues.append((character_name, character_phrase))

    return characters, dialogues
def handle_compressed_file(file_path, compressed_file_name):
    decompress(file_path, compressed_file_name)

    compressed_file_name_without_extension = compressed_file_name.split('.')[0]

    compressed_file_name_without_extension_uuid = compressed_file_name_without_extension + "_" + str(
        myid)

    compressed_file_name_uuid = compressed_file_name + "_" + str(myid)

    session['compressed_file_name'] = compressed_file_name
    session[
        'compressed_file_name_without_extension'] = compressed_file_name_without_extension
    session[
        'compressed_file_name_without_extension_uuid'] = compressed_file_name_without_extension_uuid
    session['compressed_file_name_uuid'] = compressed_file_name_uuid

    totalvocab_stemmed = []
    totalvocab_tokenized = []
    total_text = []
    file_names = []

    for filename in os.listdir(
            'uploads/extracted/' +
            str(compressed_file_name_without_extension_uuid)):
        mypath = 'uploads/extracted/' + str(
            compressed_file_name_without_extension_uuid)
        text, tokens, keywords = extract(os.path.join(mypath, filename))
        totalvocab_stemmed.extend(stem(tokens))
        totalvocab_tokenized.extend(tokens)
        total_text.append(text)
        file_names.append(filename)

    return total_text, totalvocab_stemmed, totalvocab_tokenized, file_names
    def setUpClass(self):
        if os.path.exists('temp'):
            shutil.rmtree('temp')
        os.mkdir('temp')
        os.mkdir('temp/discussion')
        os.mkdir('temp/methods')
        os.mkdir('temp/all_text')
        os.mkdir('temp/images')

        from extractor import extract
        self.responses = {'10.1101/2020.11.25.20238915': self.normalize_json(extract('10.1101/2020.11.25.20238915', False, False, False)),
                          '10.1101/2020.11.10.374587': self.normalize_json(extract('10.1101/2020.11.10.374587', True, False, False)),
                          '10.1101/2020.11.24.20238287': self.normalize_json(extract('10.1101/2020.11.24.20238287', False, False, False))}
        self.test_cases = {'10.1101/2020.11.25.20238915': json.loads(open('test/extract_test_cases/10.1101_2020.11.25.20238915.json', 'r', encoding='utf-8').read()),
                           '10.1101/2020.11.10.374587': json.loads(open('test/extract_test_cases/10.1101_2020.11.10.374587.json', 'r', encoding='utf-8').read()),
                           '10.1101/2020.11.24.20238287': json.loads(open('test/extract_test_cases/10.1101_2020.11.24.20238287.json', 'r', encoding='utf-8').read())}
Exemple #15
0
    def prepare_patches(self, pose, out_fname):
        markers = {
            'leye': np.concatenate((np.arange(17,22), np.arange(36,42))),
            'nose': np.arange(27,36),
            'mouth': np.arange(48,68),
            'beye': np.asarray([21,22,42,28,39]),
            'lmouth': np.asarray([36,39,31,48]),
        }

        print 'Prepare patches for database {}'.format(out_fname)
        with h5py.File(self.path_out+out_fname, 'r+') as hf:
            for subject_k,subject_v in hf[pose+'/'].items():
                for segment_k,segment_v in hf[pose+'/'+subject_k+'/'].items():
                    print '{} of dataset {}'.format(segment_k, pose+'/'+subject_k)
                    faces, lms = segment_v['faces'], segment_v['lms']
                    patches = {'leye':[], 'beye':[], 'mouth':[], 'lmouth':[], 'nose':[]}
                                                    
                    for i, (face, lm) in enumerate(zip(faces, lms)):
                        # Extract patches
                        for k,v in markers.items():
                            if np.sum(lm)==0:
                                print 'There where no valid landmarks for this sample'
                                patch = np.zeros((56, 56, 3))
                            else:
                                patch = extract(face, square_bbox(lm[v]), extension=1.3, size=56)[0]

                            patches[k].append(patch)

                    for k,v in markers.items():
                        '''
                        print k
                        print np.asarray(patches[k]).shape
                        '''
                        segment_v.create_dataset(k, data=np.asarray(patches[k]))
def run():
    text = "cagrUFSC2calendar transforma sua grade de horarios em um formato para calendario (.ics)\n\
            Por padrão, as repetições dos eventos das matérias estão ligadas à data do fim do semestre\n\
            da graduação na UFSC. Entretanto, você pode definir um numero personalizado de repetições\n\
            com --repeat NUM ou uma data de fim --end Y-m-d"

    parser = argparse.ArgumentParser(
        description=text, formatter_class=argparse.RawTextHelpFormatter)
    parser.add_argument("file", help="grade de horarios em HTML")
    parser.add_argument("output", help="nome do arquivo de saida")
    parser.add_argument("--repeat",
                        help="quantidade de repetições dos eventos")
    parser.add_argument("--end", help="data final para computar repetições")
    args = parser.parse_args()

    FILE = args.file
    OUTPUT = args.output
    REPEAT = args.repeat
    END_DATE = args.end

    if not END_DATE:
        END_DATE = "2020-7-14"

    print("Starting to extract information from", FILE, "...")
    daily_events, day2abrev, day2key, code2name = extract(FILE)
    print("Building calendar...")
    build(OUTPUT, END_DATE, REPEAT, daily_events, day2abrev, day2key,
          code2name)
Exemple #17
0
def get_times(paths, runs, pattern):
    """ extracts times """
    time_min = []
    time_mean = []
    time_std = []
    fails = []
    for path in paths:
        temptime = []
        fails.append(0.)
        for run in runs:
            tempnew = ex.extract(path + 'output' + str(run),
                                 pattern,
                                 isarray=False)
            if isinstance(tempnew, pl.ndarray):
                if tempnew:
                    temptime.append(tempnew[0])
                else:
                    fails[-1] += 1.
            else:
                temptime.append(tempnew)
        time_min.append(min(temptime))
        time_mean.append(pl.mean(temptime))
        time_std.append(pl.std(temptime))
        fails[-1] /= len(runs)
    return time_min, fails, time_mean, time_std
Exemple #18
0
def digdeep(path='./',
            prefix='xv',
            refs=1,
            color=COLORS[0],
            linestyle=LINES[0]):
    """ analyze deep """
    offset = 0
    for ref in range(max(refs, 1)):
        if refs == 0:
            ref = 0
            iters = int(
                ex.extract(path + 'nonlinear.txt',
                           ex.NOXIterPattern)[-1][0]) + 1
        else:
            iters = int(
                ex.extract(path + 'nonlinear' + str(ref) + '.txt',
                           ex.NOXIterPattern)[-1][0]) + 1
        print(prefix)
        print('iters:', iters)
        n_modes = 0
        bla = pl.loadtxt(path + prefix + '_' + str(ref) + '_' + str(1) +
                         '.txt')
        if bla.ndim == 1:
            n_modes = 1
        else:
            n_modes = bla.shape[0]
        print('#modes:', n_modes)
        print(bla)
        norms = pl.zeros([iters, n_modes])
        for i in range(1, iters):
            print(
                pl.loadtxt(path + prefix + '_' + str(ref) + '_' + str(i) +
                           '.txt'))
            if n_modes == 1:
                norms[i, :] = \
                    pl.loadtxt(path+prefix+'_'+str(ref)+'_'+str(i)+'.txt')[-1]
            else:
                norms[i, :] = pl.loadtxt(path + prefix + '_' + str(ref) + '_' +
                                         str(i) + '.txt')[:, -1]
        for j in range(n_modes):
            pl.semilogy(pl.arange(1, iters) + offset,
                        norms[1:, j],
                        color=color,
                        linestyle=linestyle,
                        marker=MARKERS[j])
        offset += iters - 1
    print()
Exemple #19
0
def main():
    import urllib
    from extractor import extract, extract_img
    
    # japanese site
    
    try:
        uri = 'http://www.gizmodo.jp/2012/09/post_10869.html'
        print uri, '\n'
        print extract(urllib.urlopen(uri).read())['body'], '\n'
        print extract_img(urllib.urlopen(uri).read()), '\n'
    except:
        print sys.exc_info()[0], sys.exc_info()[1]
    
    try:
        uri = 'http://labs.cybozu.co.jp/blog/nakatani/2007/09/web_1.html'
        print uri, '\n'
        print extract(urllib.urlopen(uri).read())['body'], '\n'
        print extract_img(urllib.urlopen(uri).read()), '\n'
    except:
        print sys.exc_info()[0], sys.exc_info()[1]
    
    # english site
    
    try:
        uri = 'http://capturevision.wordpress.com/2009/08/05/music-visualizer-progress/'
        print uri, '\n'
        print extract(urllib.urlopen(uri).read())['body'], '\n'
        print extract_img(urllib.urlopen(uri).read()), '\n'
    except:
        print sys.exc_info()[0], sys.exc_info()[1]
    
    try:
        uri = 'http://www.dasprinzip.com/prinzipiell/2012/04/03/shaders-in-their-natural-habitat-episode-1/'
        print uri, '\n'
        print extract(urllib.urlopen(uri).read())['body'], '\n'
        print extract_img(urllib.urlopen(uri).read()), '\n'
    except:
        print sys.exc_info()[0], sys.exc_info()[1]
    
    try:
        uri = 'http://www.generatorx.no/20101217/abstrakt-abstrakt-jorinde-voigt/?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+generatorx+%28Generator.x%3A+Generative+strategies+in+art+%26+design%29'
        print uri, '\n'
        print extract(urllib.urlopen(uri).read())['body'], '\n'
        print extract_img(urllib.urlopen(uri).read()), '\n'
    except:
        print sys.exc_info()[0], sys.exc_info()[1]
Exemple #20
0
def extract_url():
    url = request.args.get('url', '')
    if not URL_REGEX.match(url):
        return jsonify({
            'type': 'error',
            'message': 'Invalid URL'
        }), 406
    return jsonify(type='success', message=extract(url))
Exemple #21
0
def handle_compressed_file(file_path, compressed_file_name):
    '''
    Handles the processes of decompressing a file and processing (tokenizing, parsing, etc.) its contents.
    
    Parameters
    ----------
    file_path : str
        Path of compressed file in the filing system.
    compressed_file_name : str
        Name of compressed file.

    Returns
    ----------
    total_text : list
        list of raw texts from each document.
    totalvocab_stemmed : list
        list of stemmed tokens.
    totalvocab_tokenized : list
        list of tokens.
    file_names : list
        list of file names.


    '''
    myid = session['myid']
    decompress(file_path, compressed_file_name)

    compressed_file_name_without_extension = compressed_file_name.split('.')[0]

    compressed_file_name_without_extension_uuid = compressed_file_name_without_extension + \
        "_" + str(myid)

    compressed_file_name_uuid = compressed_file_name + "_" + str(myid)

    session['compressed_file_name'] = compressed_file_name
    session[
        'compressed_file_name_without_extension'] = compressed_file_name_without_extension
    session[
        'compressed_file_name_without_extension_uuid'] = compressed_file_name_without_extension_uuid
    session['compressed_file_name_uuid'] = compressed_file_name_uuid

    totalvocab_stemmed = []
    totalvocab_tokenized = []
    total_text = []
    file_names = []

    for filename in os.listdir(
            'uploads/extracted/' +
            str(compressed_file_name_without_extension_uuid)):
        mypath = 'uploads/extracted/' + \
            str(compressed_file_name_without_extension_uuid)
        text, tokens, keywords = extract(os.path.join(mypath, filename))
        totalvocab_stemmed.extend(stem(tokens))
        totalvocab_tokenized.extend(tokens)
        total_text.append(text)
        file_names.append(filename)

    return total_text, totalvocab_stemmed, totalvocab_tokenized, file_names
Exemple #22
0
 def test_extract(self):
     a = [generate_code() for _ in range(5)]
     ans = _("The natures of {} is {} and you returned {}.")
     for e in a:
         stu_ans = extractor.extract(e)
         corr_ans = corr.extract(e)
         self.assertEqual(equal_string(corr_ans),
                          equal_string(strip_trailing_space(stu_ans)),
                          ans.format(e, corr_ans, stu_ans))
def make_page_features(pages: np.ndarray) -> pd.DataFrame:
    """
    Calculates page features (site, country, agent, etc) from urls
    :param pages: Source urls
    :return: DataFrame with features as columns and urls as index
    """
    tagged = extractor.extract(pages).set_index('page')
    # Drop useless features
    features: pd.DataFrame = tagged.drop(['term', 'marker'], axis=1)
    return features
Exemple #24
0
    def run(self):
        if not self.text:
            logging.warn("Text is EMPTY!")
            return
        itemDataSet = extract(self.text, config.getItemRegexGroup(), config.getFieldMeta())

        if self.outputHandler:
            self.outputHandler.output(itemDataSet, config.getFieldMeta())
        else:
            logging.warn("OutputHandler not found.")
Exemple #25
0
def plot_linear(file_str='./Picard.txt',
                label=None,
                save=False,
                fig=1,
                offset=0,
                linestyle='-'):
    """ plots the linear iteration and achieved tolerance """
    lin_iter = ex.extract(file_str, ex.BelosMaxItPattern)
    linatol = ex.extract(file_str, ex.BelosArTolPattern)
    print(linatol)
    pl.figure(fig)
    if isinstance(lin_iter, float):  # wtf
        lin_iter = [lin_iter]
    pl.plot(pl.arange(1,
                      len(lin_iter) + 1) + offset,
            lin_iter,
            marker='.',
            label=label,
            linestyle=linestyle)
    pl.xlabel('Picard step')
    pl.ylabel(r'linear iteration steps', ha='left', va='bottom', rotation=0)
    pl.gca().yaxis.set_label_coords(-0.08, 1.02)
    pl.gca().get_yaxis().set_major_locator(pl.MaxNLocator(integer=True))
    if save:
        pl.savefig('liniter.pdf', bbox_inches='tight')
    #
    pl.figure(fig + 1)
    pl.semilogy(pl.arange(1,
                          len(linatol) + 1) + offset,
                linatol,
                marker='.',
                label=label,
                linestyle=linestyle)
    pl.xlabel('Picard step')
    # pl.ylabel(r'achieved tolerance of the linear solver', ha='left',
    # va='bottom', rotation=0)
    # pl.gca().yaxis.set_label_coords(-0.08, 1.02)
    pl.ylabel(r'achieved tolerance of the linear solver')
    pl.gca().get_xaxis().set_major_locator(pl.MaxNLocator(integer=True))
    if save:
        pl.savefig('lintol.pdf', bbox_inches='tight')
    offset += len(linatol)
    return offset
    def process(self):
        subtitleTemp = []
        for sub in self.subtitles:
            if type(sub) is dict:
                for key,value in sub.items():
                    for index,val in enumerate(value):
                        subtitleTemp.append(val)


       
        self.subtitleList = extractor.extract(subtitleTemp)
Exemple #27
0
def extract_url():
    url = request.args.get('url', '')
    err = "enter a valid URL"
    if not URL_REGEX.match(url):
        return render_template('index.html', error='"{}"'.format(err))
    message = extract(url)
    return render_template('index.html',
                           headline='"{}"'.format(message[0]),
                           title_out='"{}"'.format(message[2]),
                           news='"{}"'.format(message[1]),
                           text_out='"{}"'.format(message[3]))
Exemple #28
0
    def test_extract(self):
        test_uri = (
            "s3://ele-gv-o2/16694214/SFN00000/HRTE5/37N070E/373300N0701200E_20121101000000_BKEYE_100_QCS_00_0_UFO.tif"
        )

        extractor = Generic.GdalExtractor(test_uri)

        resp = extractor.extract()
        self.assertIsNotNone(resp)
        print(
            json.dumps(resp, sort_keys=True, indent=4, separators=(',', ': ')))
def get_fresh_userdata():
    try:
        tarball = "http://xbmc.svn.sourceforge.net/viewvc/xbmc/branches/xbox/userdata.tar.gz?view=tar"
        targz = os.path.join(PLATFORM_DIR, "userdata.tar.gz")
        fp, h = urllib.urlretrieve(tarball, targz)
        from extractor import extract
        OK = extract(fp, PLATFORM_DIR)[1]
        os.remove(targz)
        del extract
    except:
        print_exc()
Exemple #30
0
    def run(self):
        if not self.text:
            logging.warn("Text is EMPTY!")
            return
        itemDataSet = extract(self.text, config.getItemRegexGroup(),
                              config.getFieldMeta())

        if self.outputHandler:
            self.outputHandler.output(itemDataSet, config.getFieldMeta())
        else:
            logging.warn("OutputHandler not found.")
def get_fresh_userdata():
    try:
        tarball = "http://xbmc.svn.sourceforge.net/viewvc/xbmc/branches/xbox/userdata.tar.gz?view=tar"
        targz = os.path.join(PLATFORM_DIR, "userdata.tar.gz")
        fp, h = urllib.urlretrieve(tarball, targz)
        from extractor import extract

        OK = extract(fp, PLATFORM_DIR)[1]
        os.remove(targz)
        del extract
    except:
        print_exc()
Exemple #32
0
def process_examples_folder(examples_folder):
  for class_num in classes.keys():
    class_path = os.path.join(examples_folder, class_num)
    for example in os.listdir(class_path):
      example_path = os.path.join(class_path, example)
      if os.path.isfile(example_path):
        continue
      count = int(open(os.path.join(example_path, 'count.txt')).read())
      for frame_number in frame_numbers_for_count(count):
        frame_path = os.path.join(example_path, "frame-%04d.jpg" % frame_number)
        frame_features = extractor.extract(frame_path)
        for feature in feature_names:
          sys.stdout.write('%.15f,' % frame_features[feature])
      sys.stdout.write('%s\n' % class_num)    
Exemple #33
0
    def build(self):
        Window.clearcolor = (0, 0, 0, 1)
        Window.fullscreen = 'auto'
        Window.bind(on_key_down=self.press)

        #create data dictionary
        self.info = extract('telemetry2.xlsx')
        self.main.info = self.info
        self.diagnostics.info = self.info
        self.diagnostics.tabs.info = self.info 

        #Clock.schedule_interval(self.readserial, 0.05)
        Clock.schedule_interval(self.noserial, 0.5)
        return self.sm
Exemple #34
0
    def extractItem(self, msgFunc=None, progressBar=None):
        """
        Extract item in temp location
        Update:
        temp_item_path
        install_path
        name
        """
        #TODO: update a progress bar during extraction
        status = "OK"  # Status of download :[OK | ERROR | CANCELED]
        percent = 33
        # Check if the archive exists
        xbmc.log("extractItem", xbmc.LOGDEBUG)
        if (os.path.exists(self.itemInfo["raw_item_path"])
                and TYPE_SYSTEM_ARCHIVE == self.itemInfo["raw_item_sys_type"]):
            if progressBar != None:
                progressBar.update(percent, "Extraction:",
                                   (self.itemInfo["name"]))
                import extractor
                process_error = False
                # Extraction in cache directory (if OK copy later on to the correct location)
                file_path, OK = extractor.extract(
                    self.itemInfo["raw_item_path"],
                    destination=self.CACHEDIR,
                    report=True)

                xbmc.log("extractItem - file_path: %s" % file_path,
                         xbmc.LOGDEBUG)
                if file_path == "":
                    installError = _(30139) % os.path.basename(
                        self.itemInfo["raw_item_path"])
                    xbmc.log(
                        "ArchItemInstaller - extractItem: Error during the extraction of %s - impossible to extract the name of the directory "
                        % os.path.basename(self.itemInfo["raw_item_path"]),
                        xbmc.LOGNOTICE)
                    status = "ERROR"
                else:
                    # Extraction successful
                    self.itemInfo["temp_item_path"] = file_path
                del extractor

            percent = 100
            if progressBar != None:
                progressBar.update(percent, _(30182), self.itemInfo["name"])
        else:
            xbmc.log(
                "extractItem - Archive does not exist - extraction impossible",
                xbmc.LOGNOTICE)
            status = "ERROR"
        return status
Exemple #35
0
    def find_stars(self, catalogue_name=None, cattype='imcore', extension=1):
        """
        Find stars on image.

        Parameters
        -----------

        catalogue_name: string, optional
            file name of extracted catalogue

        cattype: string, optional
            type of catalogue (imcore|sextractor|python)

        extension: integer, optional
            catalogue extension to read
        """

        self.cattype=cattype

        if self.cattype=='imcore':
            logger.info('Using imcore object extractor')
            if not catalogue_name:
                catalogue_name = self.image_name.replace('.fit', '_cat.fit')
            if not os.access(catalogue_name, os.R_OK):
                imcore(self.image_name, confmap='auto')
                
            cat = fits.open(catalogue_name)
            xcat = cat[extension].data.field('x_coordinate')
            ycat = cat[extension].data.field('y_coordinate')
            
            # We read in classification and ellipticity 
            # and select only point-like objects
            classification = cat[extension].data.field('classification')
            ellipticity = cat[extension].data.field('ellipticity')
            mask = (classification == -1) & (ellipticity < 0.1)
            
            xcat, ycat = xcat[mask], ycat[mask]
            cat.close()
        elif self.cattype=='sextractor':
            logger.error('Sextractor catalogue type not yet implemented')
            xcat = ycat = 0.0
        elif self.cattype=='python':
            logger.info('Using Python object extractor')
            import extractor
            t = extractor.extract(self.fh[extension].data)
            xcat, ycat = t['x'], t['y']

        return (xcat, ycat)
def main():
    input_filename = 'data/input00.txt'
    output_filename = 'data/output00.txt'
    (train_features, train_labels,test_features, test_labels) = ex.extract(input_filename, output_filename)
    classifiers = {
        "NB Multinomial" : MultinomialNB(),
        "NB Gaussian": GaussianNB(),
        "Logistic Regression" : LogisticRegression(C=1e5, tol=0.001, fit_intercept=True),
        "Decision Tree" : DecisionTreeClassifier(min_samples_split=1, random_state=0),
        "KNN" : KNeighborsClassifier(n_neighbors=3),
        "SVM" : SVC(gamma=2, C=1),
        "LDA" : LDA(),
        "QDA" : QDA(reg_param=0.5),
        "Random Forest" : RandomForestClassifier(n_estimators=200),
        "AdaBoost" : AdaBoostClassifier(n_estimators=200),
    }
    
    print "-"*80, "\n", "Raw Dataset", "\n", "-"*80
    for name, classifier in classifiers.iteritems():
        clf = classifier.fit(train_features,train_labels)
        print name, clf.score(test_features,test_labels)
    
    print "-"*80, "\n", "Scaled Feature Dataset", "\n", "-"*80
    for name, classifier in classifiers.iteritems():
        (new_features,new_lables) = scaled_features(train_features, train_labels)
        clf = classifier.fit(new_features,new_lables)
        (new_test_features,new_test_lables) = scaled_features(train_features, train_labels)
        print name, clf.score(new_test_features,new_test_lables)
    
    print "-"*80, "\n", "Lasso Feature Selection", "\n", "-"*80
    for name, classifier in classifiers.iteritems():
        (new_features,new_lables) = extract_features(extract_lasso_features_indexes(train_features, train_labels),train_features, train_labels)
        clf = classifier.fit(new_features,new_lables)
        (new_test_features,new_test_lables) = extract_features(extract_lasso_features_indexes(train_features, train_labels),test_features,test_labels)
        print name, clf.score(new_test_features,new_test_lables)
    
    print "-"*80, "\n", "Linear Feature Selection", "\n", "-"*80
    for name, classifier in classifiers.iteritems():
        (new_features,new_lables) = extract_features(extract_linear_features_indexes(train_features, train_labels),train_features, train_labels)
        clf = classifier.fit(new_features,new_lables)
        (new_test_features,new_test_lables) = extract_features(extract_linear_features_indexes(train_features, train_labels),test_features,test_labels)
        print name, clf.score(new_test_features,new_test_lables)
Exemple #37
0
    def extractItem( self, msgFunc=None,progressBar=None ):
        """
        Extract item in temp location
        Update:
        temp_item_path
        install_path
        name
        """
        #TODO: update a progress bar during extraction
        status  = "OK" # Status of download :[OK | ERROR | CANCELED]
        percent = 33
        # Check if the archive exists
        xbmc.log("extractItem", xbmc.LOGDEBUG)
        if ( os.path.exists( self.itemInfo[ "raw_item_path" ] ) and TYPE_SYSTEM_ARCHIVE == self.itemInfo[ "raw_item_sys_type" ] ):
            if progressBar != None:
                progressBar.update( percent, "Extraction:", ( self.itemInfo [ "name" ] ) )
                import extractor
                process_error = False
                # Extraction in cache directory (if OK copy later on to the correct location)
                file_path, OK = extractor.extract( self.itemInfo [ "raw_item_path" ], destination=self.CACHEDIR, report=True )

                xbmc.log("extractItem - file_path: %s"%file_path, xbmc.LOGDEBUG)
                if file_path == "":
                    installError = _( 30139 ) % os.path.basename( self.itemInfo[ "raw_item_path" ] )
                    xbmc.log("ArchItemInstaller - extractItem: Error during the extraction of %s - impossible to extract the name of the directory " % os.path.basename( self.itemInfo [ "raw_item_path" ] ), xbmc.LOGNOTICE)
                    status = "ERROR"
                else:
                    # Extraction successful
                    self.itemInfo[ "temp_item_path" ] = file_path
                del extractor

            percent = 100
            if progressBar != None:
                progressBar.update( percent, _( 30182 ), self.itemInfo [ "name" ] )
        else:
            xbmc.log("extractItem - Archive does not exist - extraction impossible", xbmc.LOGNOTICE)
            status = "ERROR"
        return status
Exemple #38
0
    def extractItem( self, msgFunc=None,progressBar=None ):
        """
        Extract item in temp location
        """
        #TODO: update a progress bar during extraction
        print "extractItem - path" 
        print self.downloadArchivePath
        status  = "OK" # Status of download :[OK | ERROR | CANCELED]      
        percent = 33
        # Check if the archive exists
        if os.path.exists( self.downloadArchivePath ):
            if progressBar != None:
                progressBar.update( percent, "Extraction:", ( self.name ) )
#            if not self.downloadArchivePath.endswith( 'zip' ) and not self.downloadArchivePath.endswith( 'rar' ):
#                # Unknow extention, let's try few well known types:
#                # zip
#                self.downloadArchivePath =  self.downloadArchivePath + ".zip"
 
            if self.downloadArchivePath.endswith( 'zip' ) or self.downloadArchivePath.endswith( 'rar' ):
                import extractor
                process_error = False
                # Extraction in cache directory (if OK copy later on to the correct location)
                file_path, OK = extractor.extract( self.downloadArchivePath, report=True )

                if Item.TYPE_SCRAPER + "_" in self.type:
                    # Scrapers
                    # ----------------
                    if ( OK == bool( file_path ) ) and os.path.exists( file_path ):
                        # Extraction sucessfull
                        self.destinationPath = self.typeInstallPath
                        self.extractedDirPath = file_path
                        
                        # Get scraper file's name
                        try:
                            self.scraperFileList = os.listdir( str( self.extractedDirPath ) )
                            self.installName = os.path.splitext(self.scraperFileList[0])[0]
                            print "self.scraperFileList"
                            print self.scraperFileList
                        except Exception, e:
                            print "ArchItemInstaller: Exception in extractItem while listing scraper files: %s" % self.extractedDirPath
                            print_exc()
                    else:
                        status = "ERROR"
                else:
                    # Cas des scripts et plugins
                    # --------------------------
                    # Recuperons le nom du repertoire a l'interieur de l'archive:
                    dirName = ""
                    if ( OK == bool( file_path ) ) and os.path.exists( file_path ):
                        dirName = os.path.basename( file_path )
                        
    
                    if dirName == "":
                        installError = _( 139 ) % os.path.basename( self.downloadArchivePath )
                        print "Error during the extraction of %s - impossible to extract the name of the directory " % os.path.basename( self.downloadArchivePath )
                        status = "ERROR"
                    else:
                        # Extraction successful
                        self.destinationPath = os.path.join( self.typeInstallPath, os.path.basename( file_path ) )
                        self.installName = os.path.basename( file_path )
                        self.extractedDirPath = file_path
                        print self.destinationPath
                #TODO: add skin case (requirements need to be defined first)
                del extractor
                
                #print self.type
                #print self.destinationPath
                #print self.extractedDirPath
            percent = 100
            if progressBar != None:
                progressBar.update( percent, _( 182 ), self.name )
Exemple #39
0
def main():
    for testcase in testcases:
        print '[%s] %s %s' % (datetime.today().strftime('%Y-%m-%d %H:%M:%S'), '\033[35m' + 'testing' + '\033[0m', testcase['uri'])
        evaluate(testcase, extract(urllib.urlopen(testcase['uri']).read()))
def createExcel():
    [plantgoed, verkoopbare, coniferen, bomen] = extract()
    font0 = Font()
    font0.name = 'Arial'
    font0.colour_index = 0
    font0.bold = False
    font0.height = 10*20
    
    text = XFStyle()
    text.font = font0
    
    prijs = XFStyle()
    prijs.font = font0
    prijs.num_format_str = '"$"#,##0.00_);("$"#,##'
    
    ver = open_workbook('extractor/verk.xls',formatting_info=True)
    plg = open_workbook('extractor/plg.xls',formatting_info=True)
    all = open_workbook('extractor/all.xls',formatting_info=True)
    verkoopwb = copy(ver)
    plgwb = copy(plg)
    allwb = copy(all)
    
    verkoopwb.add_style(text)
    verkoopwb.add_style(prijs)
    plgwb.add_style(text)
    plgwb.add_style(prijs)
    allwb.add_style(text)
    allwb.add_style(prijs)
    
    #all
    plg1 = allwb.get_sheet(0)
    verk1 = allwb.get_sheet(1)
    con1 = allwb.get_sheet(2)
    
    #verkoopbare
    verk2 = verkoopwb.get_sheet(0)
    con2 = verkoopwb.get_sheet(1)
    bomen2 = verkoopwb.get_sheet(2)
    
    #plgList
    plg2 = plgwb.get_sheet(0)
    
    plgc = 14
    verkc = 14
    conc = 14
    bomc = 14
    
    for i in xrange(len(plantgoed)):
        plg1.write(plgc, 0, plantgoed[i]['beschrijving'], text)
        plg1.write(plgc, 1, plantgoed[i]['aantal'], text)
        plg1.write(plgc, 2, plantgoed[i]['prijs'], prijs)
        plg2.write(plgc, 0, plantgoed[i]['beschrijving'], text)
        plg2.write(plgc, 1, plantgoed[i]['aantal'], text)
        plg2.write(plgc, 2, plantgoed[i]['prijs'], prijs)
        plgc+=1
        
    for i in xrange(len(verkoopbare)):
        verk1.write(verkc, 0, verkoopbare[i]['beschrijving'], text)
        verk1.write(verkc, 1, verkoopbare[i]['aantal'], text)
        verk1.write(verkc, 2, verkoopbare[i]['prijs'], prijs)
        verk2.write(verkc, 0, verkoopbare[i]['beschrijving'], text)
        verk2.write(verkc, 1, verkoopbare[i]['aantal'], text)
        verk2.write(verkc, 2, verkoopbare[i]['prijs'], prijs)
        verkc+=1
        
    for i in xrange(len(coniferen)):
        con1.write(conc, 0, coniferen[i]['beschrijving'], text)
        con1.write(conc, 1, coniferen[i]['aantal'], text)
        con1.write(conc, 2, coniferen[i]['prijs'], prijs)
        con2.write(conc, 0, coniferen[i]['beschrijving'], text)
        con2.write(conc, 1, coniferen[i]['aantal'], text)
        con2.write(conc, 2, coniferen[i]['prijs'], prijs)
        conc+=1
		
    for i in xrange(len(bomen)):
        bomen2.write(bomc, 0, bomen[i]['beschrijving'], text)
        bomen2.write(bomc, 1, bomen[i]['aantal'], text)
        bomen2.write(bomc, 2, bomen[i]['prijs'], prijs)
        bomc+=1

    year = datetime.datetime.now().year
    #insert kapelhof logo to each worksheet:
    plg1.insert_bitmap('extractor/kapelhof.bmp', 0, 1)
    plg2.insert_bitmap('extractor/kapelhof.bmp', 0, 1)
    verk1.insert_bitmap('extractor/kapelhof.bmp', 0, 1)
    verk2.insert_bitmap('extractor/kapelhof.bmp', 0, 1)
    con1.insert_bitmap('extractor/kapelhof.bmp', 0, 1)
    con2.insert_bitmap('extractor/kapelhof.bmp', 0, 1)
    bomen2.insert_bitmap('extractor/kapelhof.bmp', 0, 1)

    verkoopwb.save('voorraadslijst_verkoopbare_planten_' + str(year) + '-' + str(year+1) + '.xls')
    plgwb.save('voorraadslijst_plantgoed_' + str(year) + '-' + str(year+1) + '.xls')
    allwb.save('voorraadslijst_' + str(year) + '-' + str(year+1) + '.xls')
    return True
Exemple #41
0
#!/usr/bin/env python
import extractor
from extractor import Keypoint
import numpy as np

"""
This is extractor file, it creates a keypoint
"""

kps = [Keypoint(1.0, 2.0, 3.0),
        Keypoint(4.0, 5.0, 6.0),
        Keypoint(7.0, 8.0, 9.0)]

output = extractor.extract(kps)

print "Output: %s" %(str(output))

print ""

def do():
    """
    this function does stuff
    """
    for kp in kps:
        print kp

do()



Exemple #42
0
            # download
            dret = None
            if len(files) == 0:
                downloader.download(conns, downloadPath, pars, False, guiInfo)
            else:
                dret = downloader.download(conns, downloadPath, files, False, guiInfo)
        
            # verify / extract
            vret = None
            if not len(files) == 0:
                if cfg.get("automation","verify") == "true":
                    vret = verifier.verify(conns, downloadPath, pars)
                # TODO: extract download
                if cfg.get("automation","extract") == "true":
                    if vret != -1:
                        extractor.extract(downloadPath)
                        
            # generate nfo file
            if dret:
                vresult = ""
                if vret == None or vret == 2:
                    vresult = "???"
                elif vret == 1:
                    vresult = "Passed"
                elif vret == 3:
                    vresult = "Repaired"
                else:
                    vresult = "Failed"

                f = open(downloadPath + "newzBoy.nfo", "w")
                f.write(utils.nfo(folderName, dret["size"], dret["files"], dret["speed"], dret["time"],vresult))