#Copyright ReportLab Europe Ltd. 2000-2006

#see license.txt for license details

# $URI:$

__version__=''' $Id$ '''

__doc__='''Gazillions of miscellaneous internal utility functions'''

try:

    from hashlib import md5

except:

    from md5 import md5

from reportlab.lib.logger import warnOnce

from types import *

from rltempfile import get_rl_tempfile, get_rl_tempdir, _rl_getuid

SeqTypes = (ListType,TupleType)

if sys.hexversion<0x2020000:

    def isSeqType(v):

        return type(v) in SeqTypes

else:

    def isSeqType(v):

        return isinstance(v,(tuple,list))

if sys.hexversion<0x2030000:

    True = 1

    False = 0

if sys.hexversion >= 0x02000000:

    def _digester(s):

        return md5(s).hexdigest()

else:

    # hexdigest not available in 1.5

    def _digester(s):

        return join(map(lambda x : "%02x" % ord(x), md5(s).digest()), '')

def _findFiles(dirList,ext='.ttf'):

    from os.path import isfile, isdir, join as path_join

    from os import listdir

    ext = ext.lower()

    R = []

    A = R.append

    for D in dirList:

        if not isdir(D): continue

        for fn in listdir(D):

            fn = path_join(D,fn)

            if isfile(fn) and (not ext or fn.lower().endswith(ext)): A(fn)

    return R

try:

    _UserDict = dict

except:

    from UserDict import UserDict as _UserDict

class CIDict(_UserDict):

    def __init__(self,*a,**kw):

        map(self.update, a)

        self.update(kw)

    def update(self,D):

        for k,v in D.items(): self[k] = v

    def __setitem__(self,k,v):

        try:

            k = k.lower()

        except:

            pass

        _UserDict.__setitem__(self,k,v)

    def __getitem__(self,k):

        try:

            k = k.lower()

        except:

            pass

        return _UserDict.__getitem__(self,k)

    def __delitem__(self,k):

        try:

            k = k.lower()

        except:

            pass

        return _UserDict.__delitem__(self,k)

    def get(self,k,dv=None):

        try:

            return self[k]

        except KeyError:

            return dv

    def has_key(self,k):

        try:

            self[k]

            return True

        except:

            return False

    def pop(self,k,*a):

        try:

            k = k.lower()

        except:

            pass

        return _UserDict.pop(*((self,k)+a))

    def setdefault(self,k,*a):

        try:

            k = k.lower()

        except:

            pass

        return _UserDict.setdefault(*((self,k)+a))

if os.name == 'mac':

    #with the Mac, we need to tag the file in a special

    #way so the system knows it is a PDF file.

    #This supplied by Joe Strout

    import macfs, macostools

    _KNOWN_MAC_EXT = {

        'BMP' : ('ogle','BMP '),

        'EPS' : ('ogle','EPSF'),

        'EPSF': ('ogle','EPSF'),

        'GIF' : ('ogle','GIFf'),

        'JPG' : ('ogle','JPEG'),

        'JPEG': ('ogle','JPEG'),

        'PCT' : ('ttxt','PICT'),

        'PICT': ('ttxt','PICT'),

        'PNG' : ('ogle','PNGf'),

        'PPM' : ('ogle','.PPM'),

        'TIF' : ('ogle','TIFF'),

        'TIFF': ('ogle','TIFF'),

        'PDF' : ('CARO','PDF '),

        'HTML': ('MSIE','TEXT'),

        }

    def markfilename(filename,creatorcode=None,filetype=None,ext='PDF'):

        try:

            if creatorcode is None or filetype is None and ext is not None:

                try:

                except:

                    return

            macfs.FSSpec(filename).SetCreatorType(creatorcode,filetype)

            macostools.touched(filename)

        except:

            pass

else:

    def markfilename(filename,creatorcode=None,filetype=None):

        pass

import reportlab

__RL_DIR=os.path.dirname(reportlab.__file__)    #possibly relative

_RL_DIR=os.path.isabs(__RL_DIR) and __RL_DIR or os.path.abspath(__RL_DIR)

del reportlab

#Attempt to detect if this copy of reportlab is running in a

#file system (as opposed to mostly running in a zip or McMillan

#archive or Jar file).  This is used by test cases, so that

#we can write test cases that don't get activated in a compiled

try:

    __file__

except:

    __file__ = sys.argv[0]

import glob, fnmatch

try:

    _isFSD = not __loader__

    _archive = os.path.normcase(os.path.normpath(__loader__.archive))

    _archivepfx = _archive + os.sep

    _archivedir = os.path.dirname(_archive)

    _archivedirpfx = _archivedir + os.sep

    _archivepfxlen = len(_archivepfx)

    _archivedirpfxlen = len(_archivedirpfx)

    def __startswith_rl(fn,

                    _archivepfx=_archivepfx,

                    _archivedirpfx=_archivedirpfx,

                    _archive=_archive,

                    _archivedir=_archivedir,

                    os_path_normpath=os.path.normpath,

                    os_path_normcase=os.path.normcase,

                    os_getcwd=os.getcwd,

                    os_sep=os.sep,

                    os_sep_len = len(os.sep)):

        '''if the name starts with a known prefix strip it off'''

        fn = os_path_normpath(fn.replace('/',os_sep))

        nfn = os_path_normcase(fn)

        if nfn in (_archivedir,_archive): return 1,''

        if nfn.startswith(_archivepfx): return 1,fn[_archivepfxlen:]

        if nfn.startswith(_archivedirpfx): return 1,fn[_archivedirpfxlen:]

        cwd = os_path_normcase(os_getcwd())

        n = len(cwd)

        if nfn.startswith(cwd):

            if fn[n:].startswith(os_sep): return 1, fn[n+os_sep_len:]

            if n==len(fn): return 1,''

        return not os.path.isabs(fn),fn

    def _startswith_rl(fn):

        return __startswith_rl(fn)[1]

    def rl_glob(pattern,glob=glob.glob,fnmatch=fnmatch.fnmatch, _RL_DIR=_RL_DIR,pjoin=os.path.join):

        c, pfn = __startswith_rl(pattern)

        r = glob(pfn)

        if c or r==[]:

            r += map(lambda x,D=_archivepfx,pjoin=pjoin: pjoin(_archivepfx,x),filter(lambda x,pfn=pfn,fnmatch=fnmatch: fnmatch(x,pfn),__loader__._files.keys()))

        return r

except:

    _isFSD = os.path.isfile(__file__)   #slight risk of wrong path

    __loader__ = None

    def _startswith_rl(fn):

        return fn

    def rl_glob(pattern,glob=glob.glob):

        return glob(pattern)

del glob, fnmatch

_isFSSD = _isFSD and os.path.isfile(os.path.splitext(__file__)[0] +'.py')

def isFileSystemDistro():

    '''return truth if a file system distribution'''

    return _isFSD

def isCompactDistro():

    '''return truth if not a file system distribution'''

    return not _isFSD

def isSourceDistro():

    '''return truth if a source file system distribution'''

    return _isFSSD

try:

    #raise ImportError

    ### NOTE!  FP_STR SHOULD PROBABLY ALWAYS DO A PYTHON STR() CONVERSION ON ARGS

    ### IN CASE THEY ARE "LAZY OBJECTS".  ACCELLERATOR DOESN'T DO THIS (YET)

    try:

        from _rl_accel import fp_str                # in case of builtin version

    except ImportError:

        from reportlab.lib._rl_accel import fp_str  # specific

except ImportError:

    from math import log

    _log_10 = lambda x,log=log,_log_e_10=log(10.0): log(x)/_log_e_10

    _fp_fmts = "%.0f", "%.1f", "%.2f", "%.3f", "%.4f", "%.5f", "%.6f"

    import re

    _tz_re = re.compile('0+$')

    del re

    def fp_str(*a):

        if len(a)==1 and isSeqType(a[0]): a = a[0]

        s = []

        A = s.append

        for i in a:

            sa =abs(i)

            if sa<=1e-7: A('0')

            else:

                l = sa<=1 and 6 or min(max(0,(6-int(_log_10(sa)))),6)

                n = _fp_fmts[l]%i

                if l:

                    n = _tz_re.sub('',n)

                    try:

                        if n[-1]=='.': n = n[:-1]

                    except:

                        print i, n

                        raise

                A((n[0]!='0' or len(n)==1) and n or n[1:])

#hack test for comma users

if ',' in fp_str(0.25):

    _FP_STR = fp_str

    def fp_str(*a):

def recursiveImport(modulename, baseDir=None, noCWD=0, debug=0):

    """Dynamically imports possible packagized module, or raises ImportError"""

    normalize = lambda x: os.path.normcase(os.path.abspath(os.path.normpath(x)))

    path = map(normalize,sys.path)

    if baseDir:

        if not isSeqType(baseDir):

            tp = [baseDir]

        else:

            tp = filter(None,list(baseDir))

        for p in tp:

            p = normalize(p)

            if p not in path: path.insert(0,p)

    if noCWD:

        for p in ('','.',normalize('.')):

            while p in path:

                if debug: print 'removed "%s" from path' % p

                path.remove(p)

    elif '.' not in path:

            path.insert(0,'.')

    if debug:

        import pprint

        pp = pprint.pprint

        print 'path=',

        pp(path)

    #make import errors a bit more informative

    opath = sys.path

    try:

        sys.path = path

        exec 'import %s\nm = %s\n' % (modulename,modulename) in locals()

        sys.path = opath

        return m

    except ImportError:

        sys.path = opath

        msg = "recursiveimport(%s,baseDir=%s) failed" % (modulename,baseDir)

        if baseDir:

            msg = msg + " under paths '%s'" % `path`

        raise ImportError, msg

def recursiveGetAttr(obj, name):

    "Can call down into e.g. object1.object2[4].attr"

    return eval(name, obj.__dict__)

def recursiveSetAttr(obj, name, value):

    "Can call down into e.g. object1.object2[4].attr = value"

    #get the thing above last.

    if len(tokens) == 1:

        setattr(obj, name, value)

    else:

        last = tokens[-1]

        parent = recursiveGetAttr(obj, most)

        setattr(parent, last, value)

def import_zlib():

    try:

        import zlib

    except ImportError:

        zlib = None

        from reportlab.rl_config import ZLIB_WARNINGS

        if ZLIB_WARNINGS: warnOnce('zlib not available')

    return zlib

# Image Capability Detection.  Set a flag haveImages

# to tell us if either PIL or Java imaging libraries present.

# define PIL_Image as either None, or an alias for the PIL.Image

# module, as there are 2 ways to import it

if sys.platform[0:4] == 'java':

    try:

        import javax.imageio

        import java.awt.image

        haveImages = 1

    except:

        haveImages = 0

else:

    try:

        from PIL import Image

    except ImportError:

        try:

            import Image

        except ImportError:

            Image = None

    haveImages = Image is not None

    if haveImages: del Image

try:

    from cStringIO import StringIO as __StringIO

except ImportError:

    from StringIO import StringIO as __StringIO

def getStringIO(buf=None):

    '''unified StringIO instance interface'''

    return buf is not None and __StringIO(buf) or __StringIO()

_StringIOKlass=__StringIO().__class__

class ArgvDictValue:

    '''A type to allow clients of getArgvDict to specify a conversion function'''

    def __init__(self,value,func):

        self.value = value

        self.func = func

def getArgvDict(**kw):

    ''' Builds a dictionary from its keyword arguments with overrides from sys.argv.

        Attempts to be smart about conversions, but the value can be an instance

        of ArgDictValue to allow specifying a conversion function.

    '''

    def handleValue(v,av,func):

        if func:

            v = func(av)

        else:

            t = type(v)

            if t is StringType:

                v = av

            elif t is FloatType:

                v = float(av)

            elif t is IntType:

                v = int(av)

            elif t is ListType:

                v = list(eval(av))

            elif t is TupleType:

                v = tuple(eval(av))

            else:

                raise TypeError, "Can't convert string '%s' to %s" % (av,str(t))

        return v

    A = sys.argv[1:]

    R = {}

    for k, v in kw.items():

        if isinstance(v,ArgvDictValue):

            v, func = v.value, v.func

        else:

            func = None

        handled = 0

        ke = k+'='

        for a in A:

                av = a[len(ke):]

                A.remove(a)

                R[k] = handleValue(v,av,func)

                handled = 1

                break

        if not handled: R[k] = handleValue(v,v,func)

    return R

def getHyphenater(hDict=None):

    try:

        from reportlab.lib.pyHnj import Hyphen

        if hDict is None: hDict=os.path.join(os.path.dirname(__file__),'hyphen.mashed')

        return Hyphen(hDict)

    except ImportError, errMsg:

        if str(errMsg)!='No module named pyHnj': raise

        return None

def _className(self):

    '''Return a shortened class name'''

    try:

        name = self.__class__.__name__

        if i>=0: return name[i+1:]

        return name

    except AttributeError:

        return str(self)

def open_for_read_by_name(name,mode='b'):

    if 'r' not in mode: mode = 'r'+mode

    try:

        return open(name,mode)

    except IOError:

        if _isFSD or __loader__ is None: raise

        #we have a __loader__, perhaps the filename starts with

        #the dirname(reportlab.__file__) or is relative

        name = _startswith_rl(name)

        s = __loader__.get_data(name)

        if 'b' not in mode and os.linesep!='\n': s = s.replace(os.linesep,'\n')

        return getStringIO(s)

import urllib

def open_for_read(name,mode='b', urlopen=urllib.urlopen):

    '''attempt to open a file or URL for reading'''

    if hasattr(name,'read'): return name

    try:

        return open_for_read_by_name(name,mode)

    except:

        try:

            return getStringIO(urlopen(name).read())

        except:

            raise IOError('Cannot open resource "%s"' % name)

del urllib

def open_and_read(name,mode='b'):

    return open_for_read(name,mode).read()

def open_and_readlines(name,mode='t'):

    return open_and_read(name,mode).split('\n')

def rl_isfile(fn,os_path_isfile=os.path.isfile):

    if hasattr(fn,'read'): return True

    if os_path_isfile(fn): return True

    if _isFSD or __loader__ is None: return False

    fn = _startswith_rl(fn)

    return fn in __loader__._files.keys()

def rl_isdir(pn,os_path_isdir=os.path.isdir,os_path_normpath=os.path.normpath):

    if os_path_isdir(pn): return True

    if _isFSD or __loader__ is None: return False

    pn = _startswith_rl(os_path_normpath(pn))

    if not pn.endswith(os.sep): pn += os.sep

    return len(filter(lambda x,pn=pn: x.startswith(pn),__loader__._files.keys()))>0

def rl_listdir(pn,os_path_isdir=os.path.isdir,os_path_normpath=os.path.normpath,os_listdir=os.listdir):

    if os_path_isdir(pn) or _isFSD or __loader__ is None: return os_listdir(pn)

    pn = _startswith_rl(os_path_normpath(pn))

    if not pn.endswith(os.sep): pn += os.sep

    return [x[len(pn):] for x in __loader__._files.keys() if x.startswith(pn)]

def rl_getmtime(pn,os_path_isfile=os.path.isfile,os_path_normpath=os.path.normpath,os_path_getmtime=os.path.getmtime,time_mktime=time.mktime):

    if os_path_isfile(pn) or _isFSD or __loader__ is None: return os_path_getmtime(pn)

    p = _startswith_rl(os_path_normpath(pn))