from __future__ import print_function


def base( s ):
    "remove extension from filename"
    return s.rsplit('.',1)[0]

def stdvec( iterable ) :
    "turn a list into a vector"
    import ROOT
    r = ROOT.vector(type(iterable[0] ))()
    for h in iterable : r.push_back( h )
    return r

def getpar( envname, default  ):
    "get an env. parameter. if default=None, throw and exception if absent"
    
    try :
        return autotype ( os.environ[envname] )
    except :
        if default == None : 
            print ('error getting environment variable', envname)
            raise()
        else : return default

def autotype( S ):
    "Return an integer or float if the string S can be converted to them."
    
    if S.strip().lower() in ['y','yes','yep','yup','true','one','affirmative'] : return 1
    if S.strip().lower() in ['n','no','nope','false','zero','none'] : return 0;    
    try: return int( S )
    except ValueError : pass
    try: return float( S )
    except ValueError : pass
    return S


def frange(start, end=None, inc=None):
    "A range function, that does floats..."

    if end == None:
        end = start + 0.0
        start = 0.0

    if inc == None:
        inc = 1.0

    L = []
    while 1:
        next = start + len(L) * inc
        if inc > 0 and next >= end:
            break
        elif inc < 0 and next <= end:
            break
        L.append(next)
        
    return L
import os, operator, copy

def for_latex( s ):
    "try to format s so that latex will parse it"
    s = s.replace('_', '\_')
    return s


class table( list ) :

    def __init__( self , *L ) :
    
        self.resolution = 150  # for 'convert'ing eps to bitmaps
        self.title = None
        
        # if L is a list, the list has the column names
        if len(L) == 1 and type(L[0]) == list or type(L[0]) == tuple: 
            self.append(list(L[0]))
            return
        
        # if L is a dict, it has key-value pairs
        if len(L) == 1 and type(L[0]) == dict :
            self.append(["key","value"])
            for k,v in L.iteritems():
                self.append([k,v])
            return
        
        # if none of the above, the aguments are the colums
        self.__init__( L )
        
        
    def read(self, filename) :
        " quick and dirty method to read ascii files , relies on no-spaces within cells"

        f = open(filename) 
        for l in f:
            if l.startswith('---') : continue
            self.append( l.split() )
            

    def clear(self) :
        while len(self) : self.pop() # should be easier way

    def set_list( self, L ) :
        self.clear()
        self.extend(L)

    def transpozed(self):
        "Return a copy with rows and coluns swapped"
        r = copy.copy(self)
        L = map(lambda *row: [elem for elem in row], *self) #huray for the internet
        r.set_list(L)
        return r
    
    def sort_by_column( self , column_name ) :
        icol = self[0].index( column_name )
        r = [self[0]] + sorted( self[1:] , key=operator.itemgetter(icol))
        self.set_list(r)

    def add_column( self, name, column ) :
        
        for i,line in enumerate( self ) :
            if i == 0 : self[i].append(name)
            else : self[i].append( column[i-1] )


    def add_columns(self):
        
        T = self.transpozed()
        rr = []        
        for r in T:
            
            try :
                s = sum([ float(x) for x in r[1:] ])
            except (TypeError, ValueError): 
                s = " - "
            rr.append(s)
        self.append(rr)


    def delete_columns( self, list_col_numbers ) :
        "delete the columns with index in list_col_numbers"
        self.set_list ( [ [ c for (i,c) in enumerate(row) if not i in list_col_numbers ] for row in self ] )


    def select_where( self , query ):

        try:
            q = query.split('=')
            colname = q[0].strip()
            value   = q[1].strip()
        except:
            print ('malformed query', query)

        try:
            icol = self[0].index(colname)
        except ValueError:
            print ("wrong column name : " , colname)
            raise

        rows = [ r for r in self if r[icol] == value ]
        r = self.get_empty_copy()
        r.extend(rows)
        return r


    def get_empty_copy( self ):
        "return a copy with all rows removed - except the header row"

        r = table( self[0] )     
        for k,v in self.__dict__.iteritems() :
            r.__dict__[k]=v
        return r

    def __str__(self) :
        return self.sprint_ascii()

    def sprint_ascii( self ) :

        TT = self.transpozed ()
        T  = TT.transpozed() # to ensure rows have equal size
        
        column_widths = [ max ([ len(str(f)) for f in c ] ) for c in TT ]
        totwidth = sum(column_widths) + len(column_widths) -1 
        
        r =''
        if self.title : r +=self.title +'\n'

        for row, irow in zip (T, range( 0,len(T)) ) :
            
            if irow == 0 : r += '-' * totwidth +'\n'

            for field , width  in zip( row, column_widths ) :
                f = "%-"+str(width)+"s"
                r += f % ( field ) +' '
            r += '\n'

            if irow == 0 : r += '-' * totwidth +'\n'
        
        r += '-' * totwidth +'\n'
        return r

    def dump( self ) :

        for row in self:
            print ("row = " , row)
            
            for f in row:
                print (f,)
            print()
            

    def print_ascii( self ) :
        print (self.sprint_ascii()) # bit silly


    def print_latex( self ) :

        TT = self.transpozed()
        T  = TT.transpozed() # to ensure rows have equal size
        n_columns = len( TT )
        
        column_widths = [ max ([ len(str(f)) for f in c ] ) for c in TT ]
        
        r =''
        if self.title : r += "\\verb|"+self.title+"| \\newline"
        r += '\\begin{tabular}{' + 'l' * n_columns + '}\n'
        
        r += '\hline\n'
        for row, irow in zip (T, range( 0,len(T)) ) :
                
            for f, i in zip (row, range (0, len(row))) :
                
                width = column_widths[i]
                fmt = "%"+str(width)+"s"
                r += for_latex ( fmt % ( f ) )
                if i != len(row) -1 : r +=' & '
                    
            r += '\\\\\n'
            if irow == 0 or irow == len(T) -1 : r += '\\hline\n'
    
        r += '\\end{tabular}\n'
        return r
            
        
    def print_eps( self , filename ) :

        f = open('tmptexfile.tex','w')
        f.write("\\documentclass{letter} \n\\begin{document}\n\\pagestyle{empty}")            
        f.write( self.print_latex () )
        f.write( '\\end{document}' )
        f.close()

        cmd ="latex tmptexfile.tex; dvips -E -o "+filename+" tmptexfile.dvi > tmplogtmplog";
        os.system( cmd )
        os.system("rm -f tmptexfile.*");
        os.system("rm -f tmplogtmplog*");

    def print_html_pre( self ): # v
        r = '<PRE>\n'+ self.sprint_ascii() +'\n</PRE>\n'
        return r

    def print_html( self ) :
        r = "<table> "
        for i,row in enumerate(self):   

            tag = "<th>" if i == 0 else "<td>"
            utag = "</th>" if i == 0 else "</td>"

            r += "<tr>"
            for cell in row :
                r += tag+ str( cell ) + utag+"\n"
            r += "</tr>"
        r += "</table><br>\n\n"
        return r

    def print_any( self, filename ):

        self.print_eps ( 'tmpepsfile.eps')
        os.system (' convert  -density '+str(self.resolution)+' tmpepsfile.eps ' + filename )
        os.system ('rm tmpepsfile.eps')



def test_table():

    #tab = table(['name','score']
    tab = table('name','score')
    tab.append( ['dude',   0   ]) 
    tab.append( ['donny',  10  ]) 
    tab.append( ['walter', 8   ])
    
    tab.title = 'lebowski'
    tab.sort_by_column('score')
    tab.print_ascii()
    tab.delete_columns([1])
    tab.print_ascii()