Changeset 9799:088015b568d9 in orange for Orange/data/io.py


Ignore:
Timestamp:
02/06/12 18:24:07 (2 years ago)
Author:
Miha Stajdohar <miha.stajdohar@…>
Branch:
default
rebase_source:
606e50cdf4ce6a6219f044dad7638f4ca56f33b4
Message:

Set attribute_load_status.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/data/io.py

    r9671 r9799  
    101101MakeStatus = Variable.MakeStatus 
    102102 
    103 def loadARFF(filename, create_on_new = MakeStatus.Incompatible, **kwargs): 
     103def loadARFF(filename, create_on_new=MakeStatus.Incompatible, **kwargs): 
    104104    """Return class:`Orange.data.Table` containing data from file in Weka ARFF format 
    105105       if there exists no .xml file with the same name. If it does, a multi-label 
     
    109109        filename = filename[:-5] 
    110110    if os.path.exists(filename + ".xml") and os.path.exists(filename + ".arff"): 
    111         xml_name = filename + ".xml"  
    112         arff_name = filename + ".arff"  
    113         return Orange.multilabel.mulan.trans_mulan_data(xml_name,arff_name,create_on_new) 
     111        xml_name = filename + ".xml" 
     112        arff_name = filename + ".arff" 
     113        return Orange.multilabel.mulan.trans_mulan_data(xml_name, arff_name, create_on_new) 
    114114    else: 
    115115        return loadARFF_Weka(filename, create_on_new) 
    116          
    117 def loadARFF_Weka(filename, create_on_new = Orange.data.variable.Variable.MakeStatus.Incompatible, **kwargs): 
     116 
     117def loadARFF_Weka(filename, create_on_new=Orange.data.variable.Variable.MakeStatus.Incompatible, **kwargs): 
    118118    """Return class:`Orange.data.Table` containing data from file in Weka ARFF format""" 
    119119    if not os.path.exists(filename) and os.path.exists(filename + ".arff"): 
    120         filename = filename + ".arff"  
    121     f = open(filename,'r') 
    122      
     120        filename = filename + ".arff" 
     121    f = open(filename, 'r') 
     122 
    123123    attributes = [] 
    124124    attributeLoadStatus = [] 
    125      
     125 
    126126    name = '' 
    127127    state = 0 # header 
     
    129129    for l in f.readlines(): 
    130130        l = l.rstrip("\n") # strip \n 
    131         l = l.replace('\t',' ') # get rid of tabs 
     131        l = l.replace('\t', ' ') # get rid of tabs 
    132132        x = l.split('%')[0] # strip comments 
    133133        if len(x.strip()) == 0: 
    134134            continue 
    135135        if state == 0 and x[0] != '@': 
    136             print "ARFF import ignoring:",x 
     136            print "ARFF import ignoring:", x 
    137137        if state == 1: 
    138138            if x[0] == '{':#sparse data format, begin with '{', ends with '}' 
    139                 r = [None]*len(attributes) 
     139                r = [None] * len(attributes) 
    140140                dd = x[1:-1] 
    141141                dd = dd.split(',') 
     
    152152                    y = xs.strip(" ") 
    153153                    if len(y) > 0: 
    154                         if y[0]=="'" or y[0]=='"': 
     154                        if y[0] == "'" or y[0] == '"': 
    155155                            r.append(xs.strip("'\"")) 
    156156                        else: 
     
    177177                    while y[idx][-1] != "'": 
    178178                        idx += 1 
    179                         atn += ' '+y[idx] 
     179                        atn += ' ' + y[idx] 
    180180                    atn = atn.strip("' ") 
    181181                else: 
     
    188188                    for y in w[0].split(','): 
    189189                        sy = y.strip(" '\"") 
    190                         if len(sy)>0: 
     190                        if len(sy) > 0: 
    191191                            vals.append(sy) 
    192192                    a, s = Variable.make(atn, Orange.data.Type.Discrete, vals, [], create_on_new) 
     
    194194                    # real... 
    195195                    a, s = Variable.make(atn, Orange.data.Type.Continuous, [], [], create_on_new) 
    196                      
     196 
    197197                attributes.append(a) 
    198198                attributeLoadStatus.append(s) 
     
    201201    lex = [] 
    202202    for dd in data: 
    203         e = Orange.data.Instance(d,dd) 
     203        e = Orange.data.Instance(d, dd) 
    204204        lex.append(e) 
    205     t = Orange.data.Table(d,lex) 
     205    t = Orange.data.Table(d, lex) 
    206206    t.name = name 
    207      
    208     if hasattr(t, "attribute_load_status"): 
    209         t.attribute_load_status = attributeLoadStatus 
     207 
     208    #if hasattr(t, "attribute_load_status"): 
     209    t.setattr("attribute_load_status", attributeLoadStatus) 
    210210    return t 
    211211loadARFF = Orange.misc.deprecated_keywords( 
     
    220220        filename = filename[:-5] 
    221221    #print filename 
    222     f = open(filename+'.arff','w') 
    223     f.write('@relation %s\n'%t.domain.classVar.name) 
     222    f = open(filename + '.arff', 'w') 
     223    f.write('@relation %s\n' % t.domain.classVar.name) 
    224224    # attributes 
    225225    ats = [i for i in t.domain.attributes] 
     
    240240        iname = str(i.name) 
    241241        if iname.find(" ") != -1: 
    242             iname = "'%s'"%iname 
    243         if real==1: 
    244             f.write('@attribute %s real\n'%iname) 
     242            iname = "'%s'" % iname 
     243        if real == 1: 
     244            f.write('@attribute %s real\n' % iname) 
    245245        else: 
    246             f.write('@attribute %s { '%iname) 
     246            f.write('@attribute %s { ' % iname) 
    247247            x = [] 
    248248            for j in i.values: 
    249249                s = str(j) 
    250250                if s.find(" ") == -1: 
    251                     x.append("%s"%s) 
     251                    x.append("%s" % s) 
    252252                else: 
    253                     x.append("'%s'"%s) 
     253                    x.append("'%s'" % s) 
    254254            for j in x[:-1]: 
    255                 f.write('%s,'%j) 
    256             f.write('%s }\n'%x[-1]) 
     255                f.write('%s,' % j) 
     256            f.write('%s }\n' % x[-1]) 
    257257 
    258258    # examples 
     
    263263            s = str(j[i]) 
    264264            if s.find(" ") == -1: 
    265                 x.append("%s"%s) 
     265                x.append("%s" % s) 
    266266            else: 
    267                 x.append("'%s'"%s) 
     267                x.append("'%s'" % s) 
    268268        for i in x[:-1]: 
    269             f.write('%s,'%i) 
    270         f.write('%s\n'%x[-1]) 
    271  
    272 def loadMULAN(filename, create_on_new = Orange.data.variable.Variable.MakeStatus.Incompatible, **kwargs): 
     269            f.write('%s,' % i) 
     270        f.write('%s\n' % x[-1]) 
     271 
     272def loadMULAN(filename, create_on_new=Orange.data.variable.Variable.MakeStatus.Incompatible, **kwargs): 
    273273    """Return class:`Orange.data.Table` containing data from file in Mulan ARFF and XML format""" 
    274274    if filename[-4:] == ".xml": 
    275275        filename = filename[:-4] 
    276276    if os.path.exists(filename + ".xml") and os.path.exists(filename + ".arff"): 
    277         xml_name = filename + ".xml"  
    278         arff_name = filename + ".arff"  
    279         return Orange.multilabel.mulan.trans_mulan_data(xml_name,arff_name) 
     277        xml_name = filename + ".xml" 
     278        arff_name = filename + ".arff" 
     279        return Orange.multilabel.mulan.trans_mulan_data(xml_name, arff_name) 
    280280    else: 
    281281        return None 
     
    309309            else: 
    310310                real = 0 
    311         if real==1: 
     311        if real == 1: 
    312312            f.write('%s: continuous.\n' % i.name) 
    313313        else: 
     
    321321    # examples 
    322322    f.close() 
    323      
     323 
    324324    f = open('%s.data' % filename_prefix, 'w') 
    325325    for j in t: 
     
    331331        f.write('%s\n' % x[-1]) 
    332332 
    333 def toR(filename,t): 
     333def toR(filename, t): 
    334334    """Save class:`Orange.data.Table` to file in R format""" 
    335335    if str.upper(filename[-2:]) == ".R": 
    336336        filename = filename[:-2] 
    337     f = open(filename+'.R','w') 
     337    f = open(filename + '.R', 'w') 
    338338 
    339339    atyp = [] 
     
    352352    for i in xrange(len(labels)): 
    353353        if atyp[i] == 2: # continuous 
    354             f.write('"%s" = c('%(labels[i])) 
     354            f.write('"%s" = c(' % (labels[i])) 
    355355            for j in xrange(len(t)): 
    356356                if t[j][i].isSpecial(): 
     
    358358                else: 
    359359                    f.write(str(t[j][i])) 
    360                 if (j == len(t)-1): 
     360                if (j == len(t) - 1): 
    361361                    f.write(')') 
    362362                else: 
     
    364364        elif atyp[i] == 1: # discrete 
    365365            if aord[i]: # ordered 
    366                 f.write('"%s" = ordered('%labels[i]) 
     366                f.write('"%s" = ordered(' % labels[i]) 
    367367            else: 
    368                 f.write('"%s" = factor('%labels[i]) 
     368                f.write('"%s" = factor(' % labels[i]) 
    369369            f.write('levels=c(') 
    370370            for j in xrange(len(as0[i].values)): 
    371                 f.write('"x%s"'%(as0[i].values[j])) 
    372                 if j == len(as0[i].values)-1: 
     371                f.write('"x%s"' % (as0[i].values[j])) 
     372                if j == len(as0[i].values) - 1: 
    373373                    f.write('),c(') 
    374374                else: 
     
    378378                    f.write('NA') 
    379379                else: 
    380                     f.write('"x%s"'%str(t[j][i])) 
    381                 if (j == len(t)-1): 
     380                    f.write('"x%s"' % str(t[j][i])) 
     381                if (j == len(t) - 1): 
    382382                    f.write('))') 
    383383                else: 
     
    385385        else: 
    386386            raise "Unknown attribute type." 
    387         if (i < len(labels)-1): 
     387        if (i < len(labels) - 1): 
    388388            f.write(',\n') 
    389389    f.write(')\n') 
    390      
     390 
    391391def toLibSVM(filename, example): 
    392392    """Save class:`Orange.data.Table` to file in LibSVM format""" 
    393393    import Orange.classification.svm 
    394394    Orange.classification.svm.tableToSVMFormat(example, open(filename, "wb")) 
    395      
     395 
    396396def loadLibSVM(filename, create_on_new=MakeStatus.Incompatible, **kwargs): 
    397397    """Return class:`Orange.data.Table` containing data from file in LibSVM format""" 
     
    401401        attributeLoadStatus[attr] = s 
    402402        return attr 
    403      
     403 
    404404    def make_disc(name, unordered): 
    405405        attr, s = Orange.data.variable.make(name, Orange.data.Type.Discrete, [], unordered, create_on_new) 
    406406        attributeLoadStatus[attr] = s 
    407407        return attr 
    408      
     408 
    409409    data = [line.split() for line in open(filename, "rb").read().splitlines() if line.strip()] 
    410410    vars = type("attr", (dict,), {"__missing__": lambda self, key: self.setdefault(key, make_float(key))})() 
     
    447447                res.append(str[start:index]) 
    448448                start = find_start = index + 1 
    449                  
     449 
    450450        elif index == -1: 
    451451            res.append(str[start:]) 
    452452    return res 
    453      
     453 
    454454def is_standard_var_def(cell): 
    455455    """Is the cell a standard variable definition (empty, cont, disc, string) 
     
    460460    except ValueError, ex: 
    461461        return False 
    462      
     462 
    463463def is_var_types_row(row): 
    464464    """ Is the row a variable type definition row (as in the orange .tab file) 
    465465    """ 
    466466    return all(map(is_standard_var_def, row)) 
    467          
     467 
    468468def var_type(cell): 
    469469    """ Return variable type from a variable type definition in cell.  
     
    488488    """ 
    489489    return map(var_type, row) 
    490      
     490 
    491491def is_var_attributes_row(row): 
    492492    """ Is the row an attribute definition row (i.e. the third row in the 
     
    533533    else: 
    534534        raise ValueError("Unknown attribute label definition") 
    535      
     535 
    536536def var_attributes(row): 
    537537    """ Return variable specifiers and label definitions for row 
    538538    """ 
    539539    return map(var_attribute, row) 
    540      
    541          
     540 
     541 
    542542class _var_placeholder(object): 
    543543    """ A place holder for an arbitrary variable while it's values are still unknown. 
     
    546546        self.name = name 
    547547        self.values = set(values) 
    548          
     548 
    549549class _disc_placeholder(_var_placeholder): 
    550550    """ A place holder for discrete variables while their values are not yet known. 
     
    560560    except ValueError: 
    561561        return False 
    562      
     562 
    563563def is_variable_cont(values, n=None, cutoff=0.5): 
    564564    """ Is variable with ``values`` in column (``n`` rows) a continuous variable.  
     
    568568        n = len(values) or 1 
    569569    return (float(cont) / n) > cutoff 
    570      
    571      
     570 
     571 
    572572def is_variable_discrete(values, n=None, cutoff=0.3): 
    573573    """ Is variable with ``values`` in column (``n`` rows) a discrete variable.  
     
    591591    file.seek(0) # Rewind 
    592592    reader = csv.reader(file, dialect=dialect) 
    593      
     593 
    594594    header = types = var_attrs = None 
    595      
     595 
    596596#    if not has_header: 
    597597#        raise ValueError("No header in the data file.") 
    598      
     598 
    599599    header = reader.next() 
    600      
     600 
    601601    if header: 
    602602        # Try to get variable definitions 
     
    604604        if is_var_types_row(types_row): 
    605605            types = var_types(types_row) 
    606      
     606 
    607607    if types: 
    608608        # Try to get the variable attributes 
     
    611611        if is_var_attributes_row(labels_row): 
    612612            var_attrs = var_attributes(labels_row) 
    613              
     613 
    614614    # If definitions not present fill with blanks 
    615615    if not types: 
     
    617617    if not var_attrs: 
    618618        var_attrs = [None] * len(header) 
    619      
     619 
    620620    # start from the beginning 
    621621    file.seek(0) 
     
    624624        if any(defined): # skip definition rows if present in the file 
    625625            reader.next() 
    626      
     626 
    627627    variables = [] 
    628628    undefined_vars = [] 
     
    646646            variables.append(_var_placeholder(name)) 
    647647            undefined_vars.append((i, variables[-1])) 
    648              
     648 
    649649    data = [] 
    650650    for row in reader: 
     
    652652        for ind, var_def in undefined_vars: 
    653653            var_def.values.add(row[ind]) 
    654      
     654 
    655655    for ind, var_def in undefined_vars: 
    656656        values = var_def.values - set(["?", ""]) # TODO: Other unknown strings? 
    657         values = sorted(values)   
     657        values = sorted(values) 
    658658        if isinstance(var_def, _disc_placeholder): 
    659659            variables[ind] = variable.make(var_def.name, Orange.data.Type.Discrete, [], values, create_new_on) 
     
    667667            else: 
    668668                raise ValueError("Strange column in the data") 
    669      
     669 
    670670    vars = [] 
    671671    vars_load_status = [] 
     
    676676        vars.append(var) 
    677677        vars_load_status.append(status) 
    678          
     678 
    679679    attributes = [] 
    680680    class_var = [] 
     
    705705            attribute_load_status.append(status) 
    706706            attribute_indices.append(i) 
    707              
     707 
    708708    if len(class_var) > 1: 
    709709        raise ValueError("Multiple class variables defined") 
    710      
     710 
    711711    class_var = class_var[0] if class_var else None 
    712      
     712 
    713713    attribute_load_status += class_var_load_status 
    714714    variable_indices = attribute_indices + class_indices 
     
    716716    domain.add_metas(metas) 
    717717    normal = [[row[i] for i in variable_indices] for row in data] 
    718     meta_part = [[row[i] for i,_ in meta_indices] for row in data] 
     718    meta_part = [[row[i] for i, _ in meta_indices] for row in data] 
    719719    table = Orange.data.Table(domain, normal) 
    720720    for ex, m_part in zip(table, meta_part): 
    721721        for (column, var), val in zip(meta_indices, m_part): 
    722722            ex[var] = var(val) 
    723              
     723 
    724724    table.metaAttributeLoadStatus = meta_attribute_load_status 
    725725    table.attributeLoadStatus = attribute_load_status 
    726      
     726 
    727727    return table 
    728728 
     
    733733        pass 
    734734    return file 
    735          
     735 
    736736def save_csv(file, table, orange_specific=True, **kwargs): 
    737737    import csv 
     
    745745    names = [v.name for v in all_vars] 
    746746    writer.writerow(names) 
    747      
     747 
    748748    if orange_specific: 
    749749        type_cells = [] 
     
    760760                raise TypeError("Unknown variable type") 
    761761        writer.writerow(type_cells) 
    762          
     762 
    763763        var_attr_cells = [] 
    764764        for spec, var in [("", v) for v in attrs] + \ 
    765                          ([("class", class_var)] if class_var else []) +\ 
     765                         ([("class", class_var)] if class_var else []) + \ 
    766766                         [("m", v) for v in metas]: 
    767              
     767 
    768768            labels = ["{0}={1}".format(*t) for t in var.attributes.items()] # TODO escape spaces 
    769769            var_attr_cells.append(" ".join([spec] if spec else [] + labels)) 
    770              
     770 
    771771        writer.writerow(var_attr_cells) 
    772          
     772 
    773773    for instance in table: 
    774774        instance = list(instance) + [instance[m] for m in metas] 
    775775        writer.writerow(instance) 
    776      
    777          
     776 
     777 
    778778register_file_type("R", None, toR, ".R") 
    779779register_file_type("Weka", loadARFF, toARFF, ".arff") 
     
    825825    """ Return a list of persistent registered (prefix, path) pairs 
    826826    """ 
    827      
     827 
    828828    global_settings_dir = Orange.misc.environ.install_dir 
    829829    user_settings_dir = Orange.misc.environ.orange_settings_dir 
     
    846846    if isinstance(path, list): 
    847847        path = os.path.pathsep.join(path) 
    848          
     848 
    849849    user_settings_dir = Orange.misc.environ.orange_settings_dir 
    850850    if not os.path.exists(user_settings_dir): 
     
    853853        except OSError: 
    854854            pass 
    855      
     855 
    856856    filename = os.path.join(user_settings_dir, "orange-search-paths.cfg") 
    857857    parser = SafeConfigParser() 
    858858    parser.read([filename]) 
    859      
     859 
    860860    if not parser.has_section("paths"): 
    861861        parser.add_section("paths") 
    862          
     862 
    863863    if path is not None: 
    864864        parser.set("paths", prefix, path) 
     
    867867        parser.remove_option("paths", prefix) 
    868868    parser.write(open(filename, "wb")) 
    869      
     869 
    870870def search_paths(prefix=None): 
    871871    """ Return a list of the registered (prefix, path) pairs. 
     
    880880    else: 
    881881        return paths 
    882      
     882 
    883883def set_search_path(prefix, path, persistent=False): 
    884884    """ Associate a search path with a prefix. 
     
    896896    """ 
    897897    global _session_paths 
    898      
     898 
    899899    if isinstance(path, list): 
    900900        path = os.path.pathsep.join(path) 
    901          
     901 
    902902    if persistent: 
    903903        save_persistent_search_path(prefix, path) 
     
    906906    else: 
    907907        _session_paths.append((prefix, path)) 
    908          
     908 
    909909 
    910910def expand_filename(prefixed_name): 
     
    926926    else: 
    927927        raise ValueError("Unknown prefix %r." % prefix) 
    928      
     928 
    929929def find_file(prefixed_name): 
    930930    """ Find the prefixed filename and return its full path. 
     
    932932    if not os.path.exists(prefixed_name): 
    933933        if ":" not in prefixed_name: 
    934             raise ValueError("Not a prefixed name.")  
    935         prefix, filename = prefixed_name.split(":", 1)  
     934            raise ValueError("Not a prefixed name.") 
     935        prefix, filename = prefixed_name.split(":", 1) 
    936936        paths = search_paths(prefix) 
    937937        if paths: 
     
    945945    else: 
    946946        return prefixed_name 
    947      
     947 
Note: See TracChangeset for help on using the changeset viewer.