def fromFile(filename, userpw):
    """Load a PDF file from a given file.  Supply a user password (possibly
    blank) in case the file is encrypted. It won't be decrypted, but sometimes
    the password is needed just to load the file."""

def fromFileLazy(filename, userpw):
    """Load a PDF from a file, doing only minimal parsing. The objects will be
    read and parsed when they are actually needed.  Use this when the whole
    file won't be required. Also supply a user password (possibly blank) in
    case the file is encrypted. It won't be decrypted, but sometimes the
    password is needed just to load the file."""

def fromMemory(data, userpw):
    """Load a file from a byte array and the user password (blank if none)."""

def fromMemoryLazy(data, userpw):
    """Load a file from from a byte array and the user password (blank if
    none), but lazily like fromFileLazy."""

def ptOfCm(i):
    """Convert a figure in centimetres to points (72 points to 1 inch)."""

def ptOfMm(i):
    """Convert a figure in millimetres to points (72 points to 1 inch)."""

def ptOfIn(i):
    """Convert a figure in inches to points (72 points to 1 inch)."""

def cmOfPt(i):
    """Convert a figure in points to centimetres (72 points to 1 inch)."""

def mmOfPt(i):
    """Convert a figure in points to millimetres (72 points to 1 inch)."""

def inOfPt(i):
    """Convert a figure in points to inches (72 points to 1 inch)."""

def parsePagespec(pdf, pagespec):
    """Parse a page specification such as "1-3,8-end" to a range with reference
    to a given PDF (the PDF is supplied so that page ranges which reference
    pages which do not exist are rejected)."""

def validatePagespec(pagespec):
    """Validate a page specification, returning True or False, so far as is
    possible in the absence of the actual document."""

def stringOfPagespec(pdf, r):
    """Build a page specification from a page range. For example, the range
    containing 1,2,3,6,7,8 in a document of 8 pages might yield "1-3,6-end"."""

def blankRange():
    """Create a range with no pages in."""

def pageRange(f, t):
    """Build a range from one page to another inclusive. For example,
    pageRange(3,7) gives the range 3,4,5,6,7."""

def all(pdf):
    """The range containing all the pages in a given document."""

def even(r):
    """A range which contains just the even pages of another range."""

def odd(r):
    """A range which contains just the odd pages of another range."""

def rangeUnion(a, b):
    """The union of two ranges giving a range containing
    the pages in range a and range b."""

def difference(a, b):
    """The difference of two ranges, giving a range
    containing all the pages in a except for those which are also in b."""

def removeDuplicates(r):
    """Deduplicates a range, returning a new one."""

def rangeLength(r):
    """The number of pages in a range."""

def rangeGet(r, n):
    """Get the page number at position n in a range, where
    n runs from 0 to rangeLength - 1."""

def rangeAdd(r, p):
    """Add the page to a range, if it is not already
    there."""

def isInRange(r, p):
    """Returns True if the page p is in the range r, False otherwise."""

def pages(pdf):
    """Return the number of pages in a PDF."""

def pagesFast(userpw, filename):
    """Return the number of pages in a given PDF, with given user password. It
    tries to do this as fast as possible, without loading the whole file."""

def toFile(pdf, filename, linearize, make_id):
    """Write the file to a given filename. If linearize is True, it will be
    linearized, if supported by libcpdf. If make_id is True, it will be given a
    new ID. NB: Unlike with the command line tool, cpdf, streams decompressed
    during processing will not automatically be compressed when writing. Call
    compress() first."""

def toFileExt(pdf, filename, linearize, make_id, preserve_objstm,
              generate_objstm, compress_objstm):
    """Write the file to a given filename. If linearize is True, it will be
    linearized, if supported by libcpdf. If make_id is True, it will be given a
    new ID.  If preserve_objstm is True, existing object streams will be
    preserved. If generate_objstm is True, object streams will be generated
    even if not originally present. If compress_objstm is True, object streams
    will be compressed (what we usually want). WARNING: the pdf argument will
    be invalid after this call and should not be used again."""

def toMemory(pdf, linearize, make_id):
    """Write a file to memory, returning the buffer as a byte array of type
    bytes. NB: Unlike with the command line tool, cpdf, streams decompressed
    during processing will not automatically be compressed when writing. Call
    compress() first."""

def isEncrypted(pdf):
    """Returns True if a documented is encrypted, False otherwise."""

def toFileEncrypted(pdf, method, permissions, ownerpw, userpw, linearize,
                    makeid, filename):
    """Write the file to a given filename encrypted with the given encryption
    method, permissions list, and owener and user passwords. If linearize is
    True, it will be linearized, if supported by libcpdf. If make_id is True,
    it will be given a new ID."""

def toFileEncryptedExt(pdf, method, permissions, ownerpw, userpw, linearize,
                       makeid, preserve_objstm, generate_objstm,
                       compress_objstm, filename):
    """Write the file to a given filename encrypted with the given encryption
    method, permissions list, and owener and user passwords. If linearize is
    True, it will be linearized, if supported by libcpdf. If make_id is True,
    it will be given a new ID. If preserve_objstm is True, existing object
    streams will be preserved. If generate_objstm is True, object streams will
    be generated even if not originally present. If compress_objstm is True,
    object streams will be compressed (what we usually want). WARNING: the pdf
    argument will be invalid after this call and should not be used again."""

def decryptPdf(pdf, userpw):
    """Attempts to decrypt a PDF using the given user password. An exception is
    raised in the event of a bad password."""

def decryptPdfOwner(pdf, ownerpw):
    """Attempts to decrypt a PDF using the given owner password. An exception
    is raised in the event of a bad password."""

def hasPermission(pdf, perm):
    """Returns True if the given permission (restriction) is present."""

def encryptionKind(pdf):
    """Return the encryption method currently in use on a document."""

def loadFont(name, filename):
    """Loads a TrueType font from the given file name, and names it. It may
    then be used when adding text or drawing, using the name in place of a
    standard font name. """