python-imprastorage/impra/util.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#                                                                               #
#   software  : ImpraStorage <http://imprastorage.sourceforge.net/>             #
#   version   : 0.8                                                             #
#   date      : 2012                                                            #
#   licence   : GPLv3.0   <http://www.gnu.org/licenses/>                        #
#   author    : a-Sansara <http://www.a-sansara.net/>                           #
#   copyright : pluie.org <http://www.pluie.org/>                               #
#                                                                               #
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
#   This file is part of ImpraStorage.
#
#   ImpraStorage is free software (free as in speech) : you can redistribute it 
#   and/or modify it under the terms of the GNU General Public License as 
#   published by the Free Software Foundation, either version 3 of the License, 
#   or (at your option) any later version.
#
#   ImpraStorage is distributed in the hope that it will be useful, but WITHOUT 
#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
#   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
#   more details.
#
#   You should have received a copy of the GNU General Public License
#   along with ImpraStorage.  If not, see <http://www.gnu.org/licenses/>.

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~ package util ~~

from base64     import urlsafe_b64encode
from inspect    import stack
from errno      import EEXIST
from hashlib    import sha256
from math       import log, floor, ceil
from os         import urandom, popen, sep, makedirs, system
from os.path    import dirname, realpath, abspath, join, getsize
from random     import choice
from re         import split as regsplit, search as regsearch, finditer as regfinditer
from subprocess import PIPE, Popen
from sys        import stderr, executable as pyexec, stdout
import platform
#~ from sys.stdout import isatty
from time       import time

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~ class Debug ~~
class Debug:
    
    ALL    = 0
    WARN   = 1
    NOTICE = 2
    INFO   = 3
    
    def __init__(self, active=True, level=3):
        """"""
        self.active = active
        self.level  = level

COLOR_MODE = True
DEBUG      = Debug(True,Debug.INFO) 

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~ methods ~~

def represents_int(s):
    """"""
    try: 
        int(s)
        return True
    except ValueError:
        return False

def quote_escape(data):
    """Escape simple quote
    :Returns: `str`
    """
    return data.replace('\'', r'\'')
    
def linefeed_escape(data):
    """Escape simple quote
    :Returns: `str`
    """
    return data.replace('\n', '\\n')
    
def get_file_content(fileName):
    """Get file content of `fileName`
    :Returns: `str`
    """
    r = open(fileName, 'rt')
    data = r.read()
    r.close()
    return data
    
def get_file_binary(fileName):
    """Get file content of `fileName`
    :Returns: `str`
    """
    r = open(fileName, 'rb')
    data = r.read()
    r.close()
    return data

def hash_sha256(data):
    """Get a sha256 hash of str `data`
    :Returns: `str`
    """
    return str(sha256(bytes(data,'utf-8')).hexdigest())

def randomFrom(val, sval=0):
    """Get a random number from range `sval=0` to `val`
    :Returns: `int`
    """
    lst = list(range(sval,val))
    return choice(lst)

def is_binary(filename):
    """Check if given filename is binary."""
    done = False
    fp = open(filename, 'rb')
    try:
        CHUNKSIZE = 1024
        while 1:
            chunk = fp.read(CHUNKSIZE)
            if b'\0' in chunk:  done = True # found null byte
            if done or len(chunk) < CHUNKSIZE: break
    finally:
        fp.close()
    return done

def get_file_path(val):
    """"""
    return abspath(dirname(val))+sep

def file_exists(path):
    """"""
    try:
        with open(path) as f: 
            exist = True
    except IOError as e:
            exist = False
    return exist

def mkdir_p(path):
    """"""
    try:
        makedirs(path)
    except OSError as e: # Python >2.5
        if e.errno == EEXIST:
            pass
        else: raise

def formatBytes(b, p=2):
    """Give a human representation of bytes size `b`
    :Returns: `str`
    """
    units = ['B', 'KB', 'MB', 'GB', 'TB']; 
    b = max(b,0);
    if b == 0 : lb= 0
    else : lb    = log(b) 
    p = floor(lb/log(1024))
    p = min(p, len(units)- 1) 
    #Uncomment one of the following alternatives
    b /= pow(1024,p)
    #b /= (1 << (10 * p)) 
    return str(round(b, 1))+' '+units[p] 

def bstr(b,enc='utf-8'):
    """"""
    return str(b, encoding=enc)

def run(cmdline):
    """"""
    try:
        p = Popen(cmdline, shell=True,stdout=PIPE, stderr=PIPE)
        cmdout, cmderr =  p.communicate()
        rcode = p.wait()
        if rcode < 0:
            mprint((stderr,"Child was terminated by signal",rcode))
        else:
            return (rcode,cmdout,cmderr)
    except OSError as e :
        return (e,cmdout,cmderr)

def __CALLER__(args=''):
    """Give basic information of caller method
    usage ::

        eval(__CALLER())
        eval(__CALLER('"%s","%s"' % (arg1,arg2)))
        
    :Returns: `str`
    """
    #global DEBUG_LEVEL, DEBUG, DEBUG_WARN
    val = "self.__class__.__name__+'.%s' % stack()[1][3]+'("+quote_escape(args)+") "
    if DEBUG.active and DEBUG.level<=DEBUG.WARN : val += "l:'+str(stack()[1][2])+' ' "
    else: val += "'"
    return val

def mprint(d='',end='\n'):
    if DEBUG.active : print(d,end=end)

if platform.system() == 'Windows' :
    SYS_CLEAR = 'cls'
else :
    SYS_CLEAR = 'clear'
clear = lambda: system(SYS_CLEAR)

   

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~ class RuTime ~~

class RuTime:
    """Give basics time stats"""    
    
    def __init__(self,label,lvl=DEBUG.NOTICE):
        """Initialize duration with appropriate label"""
        self.debug      = DEBUG.active and DEBUG.level <= lvl
        self.debugStart = self.debug and lvl < DEBUG.INFO
        self.lvl        = lvl
        self.label      = label
        self._start()
        
    
    def _start(self):
        global Clz
        if self.debug :
            Clz.print(' ==> ', Clz.fgb1, False)
            self._paramize(self.label)
            Clz.print('', Clz.OFF)
        self.sc = time()
    
    def stop(self):
        """Stop duration and print basics stats duration on console"""
        self.ec = time()
        if self.debug: self._stats()

    def _paramize(self,data):
        global Clz
        sp = [m.start() for m in regfinditer('\(', data)]
        ep = [m.start() for m in regfinditer('\)', data)]
        if len(sp) > 0 :
            Clz.print(data[:sp[0]+1], Clz.fgb3, False)
            Clz.print(data[sp[0]+1:ep[0]], Clz.fgn7, False)
            Clz.print(data[ep[0]:], Clz.fgb3, False)
        else:
            Clz.print(data, Clz.fgb3, False, True)
    
    def _stats(self):
        global Clz
        Clz.print(' <== ', Clz.fgb1, False)
        self._paramize(self.label)
        Clz.print('%.5f' % (self.ec-self.sc), Clz.fgN4)


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~ class IniFile ~~

class IniFile:
    """Read a write inifile"""
    
    def __init__(self,path):
        """"""
        self.path = path
        self.dic  = {}
        self.read()

    def isEmpty(self):
        """"""
        return len(self.dic)==0

    def has(self, key, section='main'):
        """"""
        d = self.hasSection(section) and (key in self.dic[section])
        return d
        
    def hasSection(self, section):
        """"""
        d = (section in self.dic)
        return d

    def get(self, key, section='main'):
        """"""
        v = None
        if self.has(key,section) : v = self.dic[section][key]
        return v

    def set(self, key, val, section='main'):
        """"""
        v = None
        if not section in self.dic:
            self.dic[section]  = {}
        if key in self.dic[section]:
            v = self.dic[section].pop(key)
        self.dic[section][key] = val
        return v
    
    def rem(self, key, section):
        """"""
        v = None        
        if section in self.dic :
            if key == '*' : 
                v = self.dic.pop(section)
            elif key in self.dic[section]: 
                v = self.dic[section].pop(key)
        return v
    
    def write(self,path=None):
        """"""
        if path == None : path = self.path
        content = self.toString()
        with open(path, mode='w', encoding='utf-8') as o:
            o.write(content)

    def getSections(self):
        """"""
        l = {}
        for s in self.dic:
            section = s.split('.')
            if len(section)> 1 and not section[0] in l :
                l[section[0]] = 1
        return [k for i,k in enumerate(l)]

    def toString(self,section='*'):
        """"""
        content = ''
        main    = ''
        for s in self.dic:
            if section=='*' or section+'.'==s[:len(section)+1]:
                if s!='main':
                    #~ if section=='*': content += '\n['+s+']\n'
                    #~ else : content += '\n['+s[len(section)+1:]+']\n'
                    content += '\n['+s+']\n'
                for k in sorted(self.dic[s]):
                    if s!='main' :
                        content += k.rstrip(' ')+' = '+str(self.dic[s][k])+'\n'
                    else : main += k.rstrip(' ')+' = '+str(self.dic[s][k])+'\n'
        return main + content
    
    def print(self,section='*', withoutSectionName=False):
        """"""
        a = ''
        for s in self.dic:
            if section=='*' or section+'.'==s[:len(section)+1]:
                if s!='main':
                    #~ if section=='*': content += '\n['+s+']\n'
                    #~ else : content += '\n['+s[len(section)+1:]+']\n'
                    mprint()
                    if not withoutSectionName : 
                        Clz.print('['+s+']', Clz.fgB3)
                    else: Clz.print('['+s.split('.')[1]+']', Clz.fgB3)
                for k in sorted(self.dic[s]):
                    k = k.rstrip(' ')
                    if s!='main' :
                        a = ''
                        if len(self.dic[s][k]) > 50: a = '...'
                        Clz.print(k.ljust(10,' ')+' = '       , Clz.fgn7, False)
                        if Clz.isUnix or k is not 'key' :
                            try :
                                Clz.print(self.dic[s][k][:50]+a, Clz.fgN2)
                            except Exception as e:
                                Clz.print('value is masked - generate errors in your os', Clz.fgb1)
                                pass
                        else: Clz.print('key is masked', Clz.fgb1)
    
    def read(self):
        """"""
        try:
            with open(self.path, encoding='utf-8') as o:
                csection = 'main'
                self.dic[csection] = {}  
                for l in o:
                    l = l.rstrip()
                    d = regsplit(' *= *',l,1)
                    if len(d)> 1:
                        self.dic[csection][d[0]] = d[1]
                    elif len(l)>0 and l[0]=='[':
                        csection = l.strip('[]')
                        self.dic[csection] = {}
        except IOError : pass


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~ class StrIterator ~~

class StrIterator:

    MAX_ITER = 1000
    
    def __init__(self,data):
        self.l  = len(data)
        self.p  = ceil(self.l/self.MAX_ITER)
        self.d  = []
        for x in range(self.p):
            self.d.append(data[x*self.MAX_ITER:x*self.MAX_ITER+self.MAX_ITER])

    def __iter__(self):
        self.i = 0
        return self

    def __next__(self):
        if self.i > len(self.d)-1 :
            raise StopIteration 
        self.i += 1
        return self.d[self.i-1]


# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~ class Coloriz ~~

class Coloriz:

    _MARKER        = '!§'
    """"""
    _SEP           = ';'
    """"""
    _PATTERN_COLOR = '^'+_MARKER[0]+'[nfNFbB][0-7]'+_SEP+'$'
    """"""
    _wFH   = 0x0008
    """"""
    _wBH   = 0x0080
    """"""
    _uOFF  = '\033[1;m'
    """"""
    _wOFF  = None
    """"""
    _LF    = '\n'
    """"""
    OFF    = _MARKER+_MARKER[0]+'OFF'+_SEP+_MARKER
    """"""
    isUnix = platform.system() != 'Windows'
    """"""
    
    def __init__(self):
        """Colors for both plateform are : 0: black - 1: red - 2:green - 3: yellow - 4: blue - 5: purple - 6: cyan - 7: white 
        available class members :
        foreground normal (same as bold for w32): 
           self.fgn0 -> self.fgn7
        foreground bold :
           self.fgb0 -> self.fgb7
        foreground high intensity (same as bold high intensity for w35):
           self.fgN0 -> self.fgN7
        foreground bold high intensity :
           self.fgB0 -> self.fgB7
        background
           self.bg0 -> self.bg7
        background high intensity
           self.BG0 -> self.BG7
        default colors :
            self.OFF
        
            usage : 
            pc = PColor()
            pc.print('%smon label%s:%sma value%s' % (pc.BG4+pc.fgN7, pc.OFF+pc.fgn1, pc.fgb4, pc.OFF))
        """
        global COLOR_MODE
        self.active = COLOR_MODE
        if not self.isUnix:
            j = 0
            for i in (0,4,2,6,1,5,3,7):
                exec('self._wf%i = 0x000%i' % (i,j) + '\nself._wb%i = 0x00%i0' % (i,j) + '\nself._wF%i = 0x000%i | self._wFH' % (i,j) + '\nself._wB%i = 0x00%i0 | self._wBH' % (i,j))
                # normal eq bold
                exec('self._wn%i = self._wf%i' % (i,i))
                # normal high intensity eq bold high intensity
                exec('self._wN%i = self._wF%i' % (i,i))
                j += 1
                
        if not self.isUnix :
            import impra.w32color as w32cons
            self._wOFF    = w32cons.get_text_attr()
            self._wOFFbg  = self._wOFF & 0x0070
            self._wOFFfg  = self._wOFF & 0x0007
            self.setColor = w32cons.set_text_attr

        for i in range(0,8):            
            # foreground normal
            exec('self.fgn%i = self._MARKER + self._MARKER[0] + "n%i" + self._SEP + self._MARKER' % (i,i))
            if True or isUnix : exec('self._un%i = "\\033[0;3%im"' % (i,i))
            # foreground bold
            exec('self.fgb%i = self._MARKER + self._MARKER[0] + "f%i" + self._SEP + self._MARKER' % (i,i))
            if True or isUnix : exec('self._uf%i = "\\033[1;3%im"' % (i,i))
            # foreground high intensity
            exec('self.fgN%i = self._MARKER + self._MARKER[0] + "N%i" + self._SEP + self._MARKER' % (i,i))
            if True or isUnix : exec('self._uN%i = "\\033[0;9%im"' % (i,i))
            # foreground bold high intensity
            exec('self.fgB%i = self._MARKER + self._MARKER[0] + "F%i" + self._SEP + self._MARKER' % (i,i))
            if True or isUnix : exec('self._uF%i = "\\033[1;9%im"' % (i,i))
            # background 
            exec('self.bg%i = self._MARKER + self._MARKER[0] + "b%i" + self._SEP + self._MARKER' % (i,i))
            if True or isUnix : exec('self._ub%i = "\\033[4%im"' % (i,i))
            # background high intensity
            exec('self.BG%i = self._MARKER + self._MARKER[0] + "B%i" + self._SEP + self._MARKER' % (i,i))
            if True or isUnix : exec('self._uB%i = "\\033[0;10%im"' % (i,i))

    def print(self,data,colors,endLF=True,endClz=True):
        """"""
        if DEBUG.active:
            if not endLF : ev = ''
            else: ev = self._LF
            if self.active : 
                tokens = [c.lstrip(self._MARKER[0]).rstrip(self._SEP) for c in colors.split(self._MARKER) if c is not '']
                if self.isUnix :
                    if endClz : data += self._uOFF
                    mprint(eval('self._u'+'+self._u'.join(tokens))+data,end=ev)
                else :
                    self.setColor(eval('self._w'+'|self._w'.join(tokens)))
                    mprint(data,end=ev)
                    stdout.flush()
                    if endClz : self.setColor(self._wOFF)
            else: 
                mprint(data,end=ev)

Clz = Coloriz()