reportlab: comparison src/reportlab/pdfbase/pdfdoc.py

equal deleted inserted replaced

-:29c11b905751
+:99aa837b6703
 """
 import string, types, binascii, codecs
 from reportlab.pdfbase import pdfutils
 from reportlab.pdfbase.pdfutils import LINEEND # this constant needed in both
 from reportlab import rl_config
-from reportlab.lib.utils import import_zlib, open_for_read, fp_str, _digester, makeFileName
+from reportlab.lib.utils import import_zlib, open_for_read, fp_str, makeFileName, isSeqType, isBytesType, isUnicodeType, _digester
 from reportlab.pdfbase import pdfmetrics
-try:
+from hashlib import md5
-from hashlib import md5
-except ImportError:
-from md5 import md5
 from sys import platform
-try:
+from sys import version_info
-from sys import version_info
-except: # pre-2.0
-# may be inaccurate but will at least
-#work in anything which seeks to format
-# version_info into a string
-version_info = (1,5,2,'unknown',0)
 if platform[:4] == 'java' and version_info[:2] == (2, 1):
 # workaround for list()-bug in Jython 2.1 (should be fixed in 2.2)
 def list(sequence):
 def f(x):
 PDF_VERSION_DEFAULT = (1, 3)
 PDF_SUPPORT_VERSION = dict(     #map keyword to min version that supports it
 transparency = (1, 4),
 )
-from types import InstanceType
+def format(element, document, toplevel=0):
-def format(element, document, toplevel=0, InstanceType=InstanceType):
 """Indirection step for formatting.
 Ensures that document parameters alter behaviour
 of formatting for all elements.
 """
 if hasattr(element,'__PDFObject__'):
 self.invariant = invariant
 self.setCompression(compression)
 self._pdfVersion = pdfVersion
 # signature for creating PDF ID
 sig = self.signature = md5()
-sig.update("a reportlab document")
+sig.update(b"a reportlab document")
 if not self.invariant:
 cat = _getTimeStamp()
 else:
 cat = 946684800.0
-sig.update(repr(cat)) # initialize with timestamp digest
+cat = repr(cat)
+import sys
+if sys.version_info[0] == 3:
+cat = bytes(repr(cat), 'utf-8')
+sig.update(cat) # initialize with timestamp digest
 # mapping of internal identifier ("Page001") to PDF objectnumber and generation number (34, 0)
 self.idToObjectNumberAndVersion = {}
 # mapping of internal identifier ("Page001") to PDF object (PDFPage instance)
 self.idToObject = {}
 # internal id to file location
 filename = makeFileName(getattr(filename,'name',''))
 else :
 myfile = 1
 filename = makeFileName(filename)
 f = open(filename, "wb")
-f.write(self.GetPDFData(canvas))
+data = self.GetPDFData(canvas)
+if isUnicodeType(data):
+data = data.encode('utf8')
+f.write(data)
 if myfile:
 f.close()
 import os
 if os.name=='mac':
 from reportlab.lib.utils import markfilename
 markfilename(filename) # do platform specific file junk
-if getattr(canvas,'_verbosity',None): print('saved', filename)
+if getattr(canvas,'_verbosity',None): print('saved %s' % (filename,))
 def GetPDFData(self, canvas):
 # realize delayed fonts
 for fnt in self.delayedFonts:
 fnt.addObjects(self)
 def inForm(self):
 """specify that we are in a form xobject (disable page features, etc)"""
 # don't need this check anymore since going in a form pushes old context at canvas level.
 #if self.inObject not in ["form", None]:
-#    raise ValueError, "can't go in form already in object %s" % self.inObject
+#    raise ValueError("can't go in form already in object %s" % self.inObject)
 self.inObject = "form"
 # don't need to do anything else, I think...
 def getInternalFontName(self, psfontname):
 fm = self.fontMapping
 reference = PDFObjectReference(internalname)
 D[internalname] = reference
 #print "xobjDict D", D
 return PDFDictionary(D)
-def Reference(self, object, name=None, InstanceType=InstanceType):
+def Reference(self, object, name=None):
 ### note references may "grow" during the final formatting pass: don't use d.keys()!
 # don't make references to other references, or non instances, unless they are named!
 #print"object type is ", type(object)
 iob = hasattr(object,'__PDFObject__')
 idToObject = self.idToObject
 class PDFText:
 __PDFObject__ = True
 def __init__(self, t):
 self.t = t
 def format(self, document):
-result = binascii.hexlify(document.encrypt.encode(self.t))
+t = self.t
-return "<%s>" % result
+if isUnicodeType(t):
+t = t.encode('utf-8')
+result = binascii.hexlify(document.encrypt.encode(t))
+return b"<" + result + b">"
 def __str__(self):
 dummydoc = DummyDoc()
 return self.format(dummydoc)
 def PDFnumber(n):
 self.escape = escape
 self.enc = enc
 def format(self, document):
 s = self.s
 enc = getattr(self,'enc','auto')
-if type(s) is str:
+if (isBytesType(s)):
 if enc is 'auto':
 try:
 u = s.decode(s.startswith(codecs.BOM_UTF16_BE) and 'utf16' or 'utf8')
 if _checkPdfdoc(u):
 s = u.encode('pdfdoc')
 s = codecs.BOM_UTF16_BE+u.encode('utf_16_be')
 except:
 try:
 s.decode('pdfdoc')
 except:
-import sys
+sys.stderr.write('Error in %s' % (repr(s),))
-print('Error in',repr(s), file=sys.stderr)
 raise
-elif type(s) is str:
+elif isUnicodeType(s):
 if enc is 'auto':
 if _checkPdfdoc(s):
 s = s.encode('pdfdoc')
 else:
 s = codecs.BOM_UTF16_BE+s.encode('utf_16_be')
 es = es.replace('\\012','\n')
 if escape&4 and _isbalanced(s):
 es = es.replace('\\(','(').replace('\\)',')')
 return es
 else:
-return '(%s)' % s
+return b'(' + s + b')'
 def __str__(self):
 return "(%s)" % pdfutils._escape(self.s)
 def PDFName(data,lo=chr(0x21),hi=chr(0x7e)):
 # might need to change this to class for encryption
 pdfname = "FlateDecode"
 def encode(self, text):
 from reportlab.lib.utils import import_zlib
 zlib = import_zlib()
 if not zlib: raise ImportError("cannot z-compress zlib unavailable")
+if isUnicodeType(text):
+text = text.encode('utf8')
 return zlib.compress(text)
 def decode(self, encoded):
 from reportlab.lib.utils import import_zlib
 zlib = import_zlib()
 if not zlib: raise ImportError("cannot z-decompress zlib unavailable")
 def teststream(content=None):
 #content = "" # test
 if content is None:
 content = teststreamcontent
-content = string.strip(content)
+content = content.strip()
 content = string.replace(content, "\n", LINEEND) + LINEEND
 S = PDFStream(content = content,
 filters=rl_config.useA85 and [PDFBase85Encode,PDFZCompress] or [PDFZCompress])
 # nothing else needed...
 S.__Comment__ = "test stream"
 result = self.offset
 self.offset = result+len(s)
 self.write(s)
 return result
 def format(self, document):
-strings = list(map(str, self.strings)) # final conversion, in case of lazy objects
+strings = map(str, self.strings) # final conversion, in case of lazy objects
-return string.join(strings, "")
+return "".join(strings)
 XREFFMT = '%0.10d %0.5d n'
 class PDFCrossReferenceSubsection:
 __PDFObject__ = True
 reflineend = " "+LINEEND # as per spec
 elif LINEEND=="\r\n":
 reflineend = LINEEND
 else:
 raise ValueError("bad end of line! %s" % repr(LINEEND))
-return string.join(entries, LINEEND)
+return LINEEND.join(entries)
 class PDFCrossReferenceTable:
 __PDFObject__ = True
 def __init__(self):
 raise ValueError("no crossref sections")
 L = ["xref"+LINEEND]
 for s in self.sections:
 fs = format(s, document)
 L.append(fs)
-return string.join(L, "")
+return "".join(L)
 TRAILERFMT = ("trailer%(LINEEND)s"
 "%(dict)s%(LINEEND)s"
 "startxref%(LINEEND)s"
 "%(startxref)s%(LINEEND)s"
 __RefOnly__ = 1
 # to override, set as attributes
 __Defaults__ = {"Type": PDFName("Catalog"),
 "PageMode": PDFName("UseNone"),
 }
-__NoDefault__ = string.split("""
+__NoDefault__ = """
 Dests Outlines Pages Threads AcroForm Names OpenAction PageMode URI
-ViewerPreferences PageLabels PageLayout JavaScript StructTreeRoot SpiderInfo"""
+ViewerPreferences PageLabels PageLayout JavaScript StructTreeRoot SpiderInfo""".split()
-)
 __Refs__ = __NoDefault__ # make these all into references, if present
 def format(self, document):
 self.check_format(document)
 defaults = self.__Defaults__
 Refs = self.__Refs__
 D = {}
-for k in list(defaults.keys()):
+for k in defaults.keys():
 default = defaults[k]
 v = None
 if hasattr(self, k) and getattr(self,k) is not None:
 v = getattr(self, k)
 elif default is not None:
 __Comment__ = "page tree"
 __RefOnly__ = 1
 # note: could implement page attribute inheritance...
 __Defaults__ = {"Type": PDFName("Pages"),
 }
-__NoDefault__ = string.split("Kids Count Parent")
+__NoDefault__ = "Kids Count Parent".split()
 __Refs__ = ["Parent"]
 def __init__(self):
 self.pages = []
 def __getitem__(self, item):
 return self.pages[item]
 Override_default_compilation = 0
 __RefOnly__ = 1
 __Defaults__ = {"Type": PDFName("Page"),
 # "Parent": PDFObjectReference(Pages),  # no! use document.Pages
 }
-__NoDefault__ = string.split(""" Parent
+__NoDefault__ = """Parent
 MediaBox Resources Contents CropBox Rotate Thumb Annots B Dur Hid Trans AA
 PieceInfo LastModified SeparationInfo ArtBox TrimBox BleedBox ID PZ
-Trans
+Trans""".split()
-""")
+__Refs__ = """Contents Parent ID""".split()
-__Refs__ = string.split("""
-Contents Parent ID
-""")
 pagewidth = 595
 pageheight = 842
 stream = None
 hasImages = 0
 compression = 0
 def setCompression(self, onoff):
 self.compression = onoff
 def setStream(self, code):
 if self.Override_default_compilation:
 raise ValueError("overridden! must set stream explicitly")
-from types import ListType
+if isSeqType(code):
-if type(code) is ListType:
+code = LINEEND.join(code)+LINEEND
-code = string.join(code, LINEEND)+LINEEND
 self.stream = code
 def setPageTransition(self, tranDict):
 self.Trans = PDFDictionary(tranDict)
 self.MediaBox = self.MediaBox or PDFArray(self.Rotate in (90,270) and [0,0,self.pageheight,self.pagewidth] or [0, 0, self.pagewidth, self.pageheight])
 if not self.Annots:
 self.Annots = None
 else:
 #print self.Annots
-#raise ValueError, "annotations not reimplemented yet"
+#raise ValueError("annotations not reimplemented yet")
 if not hasattr(self.Annots,'__PDFObject__'):
 self.Annots = PDFArray(self.Annots)
 if not self.Contents:
 stream = self.stream
 if not stream:
 >>"""
 class PDFOutlines0:
 __PDFObject__ = True
 __Comment__ = "TEST OUTLINE!"
-text = string.replace(DUMMYOUTLINE, "\n", LINEEND)
+text = DUMMYOUTLINE.replace("\n", LINEEND)
 __RefOnly__ = 1
 def format(self, document):
 return self.text
 class OutlineEntryObject:
 self.buildtree = []
 self.closedict = {} # dictionary of "closed" destinations in the outline
 def addOutlineEntry(self, destinationname, level=0, title=None, closed=None):
 """destinationname of None means "close the tree" """
-from types import IntType, TupleType
 if destinationname is None and level!=0:
 raise ValueError("close tree must have level of 0")
-if type(level) is not IntType: raise ValueError("level must be integer, got %s" % type(level))
+if not isinstance(level,int): raise ValueError("level must be integer, got %s" % type(level))
 if level<0: raise ValueError("negative levels not allowed")
 if title is None: title = destinationname
 currentlevel = self.currentlevel
 stack = self.levelstack
 tree = self.buildtree
 # pop off levels to match
 current = stack[-1]
 del stack[-1]
 previous = stack[-1]
 lastinprevious = previous[-1]
-if type(lastinprevious) is TupleType:
+if isinstance(lastinprevious,tuple):
 (name, sectionlist) = lastinprevious
 raise ValueError("cannot reset existing sections: " + repr(lastinprevious))
 else:
 name = lastinprevious
 sectionlist = current
 desttree = self.translateNames(canvas, nametree)
 self.setDestinations(desttree)
 def translateNames(self, canvas, object):
 "recursively translate tree of names into tree of destinations"
-from types import StringType, ListType, TupleType
-Ot = type(object)
 destinationnamestotitles = self.destinationnamestotitles
 destinationstotitles = self.destinationstotitles
 closedict = self.closedict
-if Ot is StringType:
+if isStrType(object):
 destination = canvas._bookmarkReference(object)
 title = object
 if object in destinationnamestotitles:
 title = destinationnamestotitles[object]
 else:
 destinationnamestotitles[title] = title
 destinationstotitles[destination] = title
 if object in closedict:
 closedict[destination] = 1 # mark destination closed
 return {object: canvas._bookmarkReference(object)} # name-->ref
-if Ot is ListType or Ot is TupleType:
+if isSeqType(object):
 L = []
 for o in object:
 L.append(self.translateNames(canvas, o))
-if Ot is TupleType:
+if isinstance(object,tuple):
 return tuple(L)
 return L
 # bug contributed by Benjamin Dumke <reportlab@benjamin-dumke.de>
 raise TypeError("in outline, destination name must be string: got a %s"%Ot)
 self.count = count(self.mydestinations, self.closedict)
 (self.first, self.last) = self.maketree(document, self.mydestinations, toplevel=1)
 self.ready = 1
 def maketree(self, document, destinationtree, Parent=None, toplevel=0):
-from types import ListType, TupleType, DictType
-tdestinationtree = type(destinationtree)
 if toplevel:
 levelname = "Outline"
 Parent = document.Reference(document.Outlines)
 else:
 self.count = self.count+1
 levelname = "Outline.%s" % self.count
 if Parent is None:
 raise ValueError("non-top level outline elt parent must be specified")
-if tdestinationtree is not ListType and tdestinationtree is not TupleType:
+if not isSeqType(destinationtree):
 raise ValueError("destinationtree must be list or tuple, got %s")
 nelts = len(destinationtree)
 lastindex = nelts-1
 lastelt = firstref = lastref = None
 destinationnamestotitles = self.destinationnamestotitles
 firstref = eltref
 lastref = eltref
 lastelt = eltobj # advance eltobj
 lastref = eltref
 elt = destinationtree[index]
-te = type(elt)
+if isinstance(elt,dict):
-if te is DictType:
 # simple leaf {name: dest}
 leafdict = elt
-elif te is TupleType:
+elif isinstance(elt,tuple):
 # leaf with subsections: ({name: ref}, subsections) XXXX should clean up (see count(...))
 try:
 (leafdict, subsections) = elt
 except:
 raise ValueError("destination tree elt tuple should have two elts, got %s" % len(elt))
 [(Title, Dest)] = list(leafdict.items())
 except:
 raise ValueError("bad outline leaf dictionary, should have one entry "+utf8str(elt))
 eltobj.Title = destinationnamestotitles[Title]
 eltobj.Dest = Dest
-if te is TupleType and Dest in closedict:
+if isinstance(elt,tuple) and Dest in closedict:
 # closed subsection, count should be negative
 eltobj.Count = -eltobj.Count
 return (firstref, lastref)
 def count(tree, closedict=None):
 """utility for outline: recursively count leaves in a tuple/list tree"""
 from operator import add
-from types import TupleType, ListType
+if isinstance(tree,tuple):
-tt = type(tree)
-if tt is TupleType:
 # leaf with subsections XXXX should clean up this structural usage
 (leafdict, subsections) = tree
 [(Title, Dest)] = list(leafdict.items())
 if closedict and Dest in closedict:
 return 1 # closed tree element
-if tt is TupleType or tt is ListType:
+if isSeqType(tree):
 #return reduce(add, map(count, tree))
 counts = []
 for e in tree:
 counts.append(count(e, closedict))
 return sum(counts)  #used to be: return reduce(add, counts)
 return PD.format(document)
 def copy(self):
 "shallow copy - useful in pagecatchering"
 thing = self.__klass__()
-for (k, v) in list(self.__dict__.items()):
+for k, v in self.__dict__.items():
 setattr(thing, k, v)
 return thing
 # skipping thumbnails, etc
 class Annotation:
 permitted = required+(
 "Border", "C", "T", "M", "F", "H", "BS", "AA", "AS", "Popup", "P", "AP")
 def cvtdict(self, d, escape=1):
 """transform dict args from python form to pdf string rep as needed"""
 Rect = d["Rect"]
-if type(Rect) is not bytes:
+if not isStrType(Rect):
 d["Rect"] = PDFArray(Rect)
 d["Contents"] = PDFString(d["Contents"],escape)
 return d
 def AnnotationDict(self, **kw):
 if 'escape' in kw:
 for name in self.required:
 if name not in d:
 raise ValueError("keyword argument %s missing" % name)
 d = self.cvtdict(d,escape=escape)
 permitted = self.permitted
-for name in list(d.keys()):
+for name in d.keys():
 if name not in permitted:
 raise ValueError("bad annotation dictionary name %s" % name)
 return PDFDictionary(d)
 def Dict(self):
 raise ValueError("DictString undefined for virtual superclass Annotation, must overload")
 class PDFDate:
 __PDFObject__ = True
 # gmt offset now suppported properly
 def __init__(self, invariant=rl_config.invariant, dateFormatter=None):
 if invariant:
-now = (2000,0o1,0o1,00,00,00,0)
+now = (2000,1,1,0,0,0,0)
 self.dhh = 0
 self.dmm = 0
 else:
 import time
 now = tuple(time.localtime(_getTimeStamp())[:6])
 self.ProcSet = []
 self.Properties = {}
 self.Shading = {}
 # ?by default define the basicprocs
 self.basicProcs()
-stdprocs = list(map(PDFName, string.split("PDF Text ImageB ImageC ImageI")))
+stdprocs = [PDFName(s) for s in "PDF Text ImageB ImageC ImageI".split()]
 dict_attributes = ("ColorSpace", "XObject", "ExtGState", "Font", "Pattern", "Properties", "Shading")
 def allProcs(self):
 # define all standard procsets
 self.ProcSet = self.stdprocs
 for c,s in shadingUsed.items():
 self.Shading[s] = PDFObjectReference(c)
 def format(self, document):
 D = {}
-from types import ListType, DictType
 for dname in self.dict_attributes:
 v = getattr(self, dname)
-if type(v) is DictType:
+if isinstance(v,dict):
 if v:
 dv = PDFDictionary(v)
 D[dname] = dv
 else:
 D[dname] = v
 v = self.ProcSet
 dname = "ProcSet"
-if type(v) is ListType:
+if isSeqType(v):
 if v:
 dv = PDFArray(v)
 D[dname] = dv
 else:
 D[dname] = v
 class PDFType1Font:
 """no init: set attributes explicitly"""
 __PDFObject__ = True
 __RefOnly__ = 1
 # note! /Name appears to be an undocumented attribute....
-name_attributes = string.split("Type Subtype BaseFont Name")
+name_attributes = "Type Subtype BaseFont Name".split()
 Type = "Font"
 Subtype = "Type1"
 # these attributes are assumed to already be of the right type
-local_attributes = string.split("FirstChar LastChar Widths Encoding ToUnicode FontDescriptor")
+local_attributes = "FirstChar LastChar Widths Encoding ToUnicode FontDescriptor".split()
 def format(self, document):
 D = {}
 for name in self.name_attributes:
 if hasattr(self, name):
 value = getattr(self, name)
 def __init__(self, lowerx, lowery, upperx, uppery):
 #not done
 self.lowerx = lowerx; self.lowery=lowery; self.upperx=upperx; self.uppery=uppery
 def setStreamList(self, data):
-if type(data) is list:
+if isSeqType(data):
-data = string.join(data, LINEEND)
+data = LINEEND.join(data)
 self.stream = data
 def BBoxList(self):
 "get the declared bounding box for the form as a list"
 if self.BBox:
 elif hasattr(source,'jpeg_fh'):
 self.loadImageFromSRC(source)   #it is already a PIL Image
 else:
 # it is a filename
 import os
-ext = string.lower(os.path.splitext(source)[1])
+ext = os.path.splitext(source)[1].lower()
 src = open_for_read(source)
 if not(ext in ('.jpg', '.jpeg') and self.loadImageFromJPEG(src)):
 if rl_config.useA85:
 self.loadImageFromA85(src)
 else:
 self.loadImageFromRaw(src)
 def loadImageFromA85(self,source):
 IMG=[]
-imagedata = list(map(string.strip,pdfutils.makeA85Image(source,IMG=IMG)))
+imagedata = [s.strip() for s in pdfutils.makeA85Image(source,IMG=IMG)]
-words = string.split(imagedata[1])
+words = imagedata[1].split()
-self.width, self.height = list(map(string.atoi,(words[1],words[3])))
+self.width, self.height = (int(words[1]),int(words[3]))
 self.colorSpace = {'/RGB':'DeviceRGB', '/G':'DeviceGray', '/CMYK':'DeviceCMYK'}[words[7]]
 self.bitsPerComponent = 8
 self._filters = 'ASCII85Decode','FlateDecode' #'A85','Fl'
 if IMG: self._checkTransparency(IMG[0])
 elif self.mask=='auto': self.mask = None
-self.streamContent = string.join(imagedata[3:-1],'')
+self.streamContent = ''.join(imagedata[3:-1])
 def loadImageFromJPEG(self,imageFile):
 try:
 try:
 info = pdfutils.readJPEGInfo(imageFile)
 def loadImageFromRaw(self,source):
 IMG=[]
 imagedata = pdfutils.makeRawImage(source,IMG=IMG)
 words = string.split(imagedata[1])
-self.width, self.height = list(map(string.atoi,(words[1],words[3])))
+self.width = int(words[1])
+self.height = int(words[3])
 self.colorSpace = {'/RGB':'DeviceRGB', '/G':'DeviceGray', '/CMYK':'DeviceCMYK'}[words[7]]
 self.bitsPerComponent = 8
 self._filters = 'FlateDecode', #'Fl'
 if IMG: self._checkTransparency(IMG[0])
 elif self.mask=='auto': self.mask = None
-self.streamContent = string.join(imagedata[3:-1],'')
+self.streamContent = ''.join(imagedata[3:-1])
 def _checkTransparency(self,im):
 if self.mask=='auto':
 if im._dataA:
 self.mask = None
 dict["ColorSpace"] = PDFName(self.colorSpace)
 if self.colorSpace=='DeviceCMYK' and getattr(self,'_dotrans',0):
 dict["Decode"] = PDFArray([1,0,1,0,1,0,1,0])
 elif getattr(self,'_decode',None):
 dict["Decode"] = PDFArray(self._decode)
-dict["Filter"] = PDFArray(list(map(PDFName,self._filters)))
+dict["Filter"] = PDFArray(map(PDFName,self._filters))
 dict["Length"] = len(self.streamContent)
 if self.mask: dict["Mask"] = PDFArray(self.mask)
 if getattr(self,'smask',None): dict["SMask"] = self.smask
 return S.format(document)
 d.update(kw)
 for name in self.required:
 if name not in d:
 raise ValueError("keyword argument %s missing" % name)
 permitted = self.permitted
-for name in list(d.keys()):
+for name in d.keys():
 if name not in permitted:
 raise ValueError("bad annotation dictionary name %s" % name)
 return PDFDictionary(d)
 def Dict(self, document):
 d.update(kw)
 for name in self.required:
 if name not in d:
 raise ValueError("keyword argument %s missing" % name)
 permitted = self.permitted
-for name in list(d.keys()):
+for name in d.keys():
 if name not in permitted:
 raise ValueError("bad annotation dictionary name %s" % name)
 return PDFDictionary(d)
 def Dict(self, document):

branch	py33
changeset 3723	99aa837b6703
parent 3721	0c93dd8ff567
child 3731	b233dd0577ff