SYMBOL INDEX (671 symbols across 33 files)

FILE: build_cmap.py
  function runcmd (line 8) | def runcmd(args):
  function clean (line 13) | def clean():
  function main (line 22) | def main():

FILE: pdfminer/arcfour.py
  class Arcfour (line 7) | class Arcfour:
    method __init__ (line 8) | def __init__(self, key):
    method process (line 18) | def process(self, data):

FILE: pdfminer/ascii85.py
  function ascii85decode (line 12) | def ascii85decode(data):
  function asciihexdecode (line 49) | def asciihexdecode(data):

FILE: pdfminer/cmapdb.py
  class CMapError (line 34) | class CMapError(Exception): pass
  class CMap (line 37) | class CMap:
    method __init__ (line 39) | def __init__(self, code2cid=None):
    method is_vertical (line 42) | def is_vertical(self):
    method use_cmap (line 45) | def use_cmap(self, cmap):
    method decode (line 57) | def decode(self, code):
    method dump (line 71) | def dump(self, out=sys.stdout, code2cid=None, code=None):
  class IdentityCMap (line 83) | class IdentityCMap:
    method __init__ (line 85) | def __init__(self, vertical):
    method is_vertical (line 88) | def is_vertical(self):
    method decode (line 91) | def decode(self, code):
  class UnicodeMap (line 106) | class UnicodeMap:
    method __init__ (line 108) | def __init__(self, cid2unichr=None):
    method get_unichr (line 111) | def get_unichr(self, cid):
    method dump (line 115) | def dump(self, out=sys.stdout):
  class FileCMap (line 120) | class FileCMap(CMap):
    method __init__ (line 122) | def __init__(self):
    method __repr__ (line 126) | def __repr__(self):
    method is_vertical (line 129) | def is_vertical(self):
    method set_attr (line 132) | def set_attr(self, k, v):
    method add_code2cid (line 135) | def add_code2cid(self, code, cid):
  class FileUnicodeMap (line 150) | class FileUnicodeMap(UnicodeMap):
    method __init__ (line 152) | def __init__(self):
    method __repr__ (line 156) | def __repr__(self):
    method set_attr (line 159) | def set_attr(self, k, v):
    method add_cid2unichr (line 162) | def add_cid2unichr(self, cid, code):
  class PyCMap (line 179) | class PyCMap(CMap):
    method __init__ (line 181) | def __init__(self, name, module):
    method __repr__ (line 186) | def __repr__(self):
    method is_vertical (line 189) | def is_vertical(self):
  class PyUnicodeMap (line 193) | class PyUnicodeMap(UnicodeMap):
    method __init__ (line 195) | def __init__(self, name, module, vertical):
    method __repr__ (line 203) | def __repr__(self):
  class CMapDB (line 207) | class CMapDB:
    class CMapNotFound (line 212) | class CMapNotFound(CMapError): pass
    method _load_data (line 215) | def _load_data(klass, name):
    method get_cmap (line 231) | def get_cmap(klass, name):
    method get_unicode_map (line 245) | def get_unicode_map(klass, name, vertical=False):
  class CMapParser (line 255) | class CMapParser(PSStackParser):
    method __init__ (line 257) | def __init__(self, cmap, fp):
    method run (line 262) | def run(self):
    method do_keyword (line 268) | def do_keyword(self, pos, token):
  function main (line 386) | def main(argv):

FILE: pdfminer/converter.py
  class PDFLayoutAnalyzer (line 18) | class PDFLayoutAnalyzer(PDFTextDevice):
    method __init__ (line 20) | def __init__(self, rsrcmgr, pageno=1, laparams=None):
    method begin_page (line 26) | def begin_page(self, page, ctm):
    method end_page (line 33) | def end_page(self, page):
    method begin_figure (line 41) | def begin_figure(self, name, bbox, matrix):
    method end_figure (line 45) | def end_figure(self, _):
    method render_image (line 51) | def render_image(self, name, stream):
    method paint_path (line 58) | def paint_path(self, gstate, stroke, fill, evenodd, path):
    method render_char (line 90) | def render_char(self, matrix, font, fontsize, scaling, rise, cid):
    method handle_undefined_char (line 102) | def handle_undefined_char(self, font, cid):
    method receive_layout (line 106) | def receive_layout(self, ltpage):
  class PDFPageAggregator (line 110) | class PDFPageAggregator(PDFLayoutAnalyzer):
    method __init__ (line 112) | def __init__(self, rsrcmgr, pageno=1, laparams=None):
    method receive_layout (line 116) | def receive_layout(self, ltpage):
    method get_result (line 119) | def get_result(self):
  class PDFConverter (line 125) | class PDFConverter(PDFLayoutAnalyzer):
    method __init__ (line 127) | def __init__(self, rsrcmgr, outfp, pageno=1, laparams=None):
    method write_image (line 131) | def write_image(self, image):
  class TextConverter (line 156) | class TextConverter(PDFConverter):
    method __init__ (line 158) | def __init__(self, rsrcmgr, outfp, pageno=1, laparams=None,
    method write_text (line 163) | def write_text(self, text):
    method receive_layout (line 166) | def receive_layout(self, ltpage):
    method render_image (line 183) | def render_image(self, name, stream):
    method paint_path (line 185) | def paint_path(self, gstate, stroke, fill, evenodd, path):
  class HTMLConverter (line 191) | class HTMLConverter(PDFConverter):
    method __init__ (line 208) | def __init__(self, rsrcmgr, outfp, pageno=1, laparams=None,
    method write (line 231) | def write(self, text):
    method write_header (line 234) | def write_header(self):
    method write_footer (line 239) | def write_footer(self):
    method write_text (line 244) | def write_text(self, text):
    method place_rect (line 247) | def place_rect(self, color, borderwidth, x, y, w, h):
    method place_border (line 256) | def place_border(self, color, borderwidth, item):
    method place_image (line 259) | def place_image(self, item, borderwidth, x, y, w, h):
    method place_text (line 268) | def place_text(self, color, text, x, y, size):
    method begin_textbox (line 276) | def begin_textbox(self, color, borderwidth, x, y, w, h, writing_mode):
    method put_text (line 285) | def put_text(self, text, fontname, fontsize):
    method put_newline (line 295) | def put_newline(self):
    method end_textbox (line 298) | def end_textbox(self, color):
    method receive_layout (line 304) | def receive_layout(self, ltpage):
    method close (line 366) | def close(self):
  class XMLConverter (line 370) | class XMLConverter(PDFConverter):
    method __init__ (line 372) | def __init__(self, rsrcmgr, outfp, pageno=1, laparams=None, outdir=None):
    method write_header (line 377) | def write_header(self):
    method write_footer (line 381) | def write_footer(self):
    method write_text (line 384) | def write_text(self, text):
    method receive_layout (line 387) | def receive_layout(self, ltpage):
    method close (line 459) | def close(self):

FILE: pdfminer/encodingdb.py
  function name2unicode (line 8) | def name2unicode(name):
  class EncodingDB (line 17) | class EncodingDB:
    method get_encoding (line 38) | def get_encoding(cls, name, diff=None):

FILE: pdfminer/layout.py
  class IndexAssigner (line 11) | class IndexAssigner:
    method __init__ (line 13) | def __init__(self, index=0):
    method run (line 16) | def run(self, obj):
  class LAParams (line 25) | class LAParams:
    method __init__ (line 27) | def __init__(self, line_overlap=0.5, char_margin=2.0, line_margin=0.5,...
    method __repr__ (line 50) | def __repr__(self):
  class LTItem (line 55) | class LTItem:
    method analyze (line 57) | def analyze(self, laparams):
  class LTText (line 61) | class LTText:
    method __repr__ (line 63) | def __repr__(self):
    method get_text (line 67) | def get_text(self):
  class LTComponent (line 71) | class LTComponent(LTItem):
    method __init__ (line 73) | def __init__(self, bbox):
    method __repr__ (line 77) | def __repr__(self):
    method set_bbox (line 80) | def set_bbox(self, bbox):
    method is_empty (line 90) | def is_empty(self):
    method is_hoverlap (line 93) | def is_hoverlap(self, obj):
    method hdistance (line 97) | def hdistance(self, obj):
    method hoverlap (line 104) | def hoverlap(self, obj):
    method is_voverlap (line 111) | def is_voverlap(self, obj):
    method vdistance (line 115) | def vdistance(self, obj):
    method voverlap (line 122) | def voverlap(self, obj):
  class LTCurve (line 130) | class LTCurve(LTComponent):
    method __init__ (line 132) | def __init__(self, linewidth, pts):
    method get_pts (line 137) | def get_pts(self):
  class LTLine (line 141) | class LTLine(LTCurve):
    method __init__ (line 143) | def __init__(self, linewidth, p0, p1):
  class LTRect (line 147) | class LTRect(LTCurve):
    method __init__ (line 149) | def __init__(self, linewidth, rect):
  class LTImage (line 154) | class LTImage(LTComponent):
    method __init__ (line 156) | def __init__(self, name, stream, bbox):
    method __repr__ (line 168) | def __repr__(self):
  class LTAnon (line 174) | class LTAnon(LTItem, LTText):
    method __init__ (line 176) | def __init__(self, text):
    method get_text (line 179) | def get_text(self):
  class LTChar (line 183) | class LTChar(LTComponent, LTText):
    method __init__ (line 185) | def __init__(self, matrix, font, fontsize, scaling, rise, text, textwi...
    method __repr__ (line 226) | def __repr__(self):
    method get_text (line 232) | def get_text(self):
    method is_compatible (line 235) | def is_compatible(self, obj):
  class LTContainer (line 240) | class LTContainer(LTComponent):
    method __init__ (line 242) | def __init__(self, bbox):
    method __iter__ (line 246) | def __iter__(self):
    method __len__ (line 249) | def __len__(self):
    method add (line 252) | def add(self, obj):
    method extend (line 255) | def extend(self, objs):
    method analyze (line 259) | def analyze(self, laparams):
  class LTExpandableContainer (line 264) | class LTExpandableContainer(LTContainer):
    method __init__ (line 266) | def __init__(self):
    method add (line 269) | def add(self, obj):
  class LTTextContainer (line 275) | class LTTextContainer(LTExpandableContainer, LTText):
    method __init__ (line 277) | def __init__(self):
    method get_text (line 281) | def get_text(self):
  class LTTextLine (line 285) | class LTTextLine(LTTextContainer):
    method __repr__ (line 287) | def __repr__(self):
    method _insert_anon_spaces (line 290) | def _insert_anon_spaces(self, word_margin):
    method add (line 293) | def add(self, obj):
    method analyze (line 297) | def analyze(self, laparams):
    method is_empty (line 306) | def is_empty(self):
    method find_neighbors (line 314) | def find_neighbors(self, plane, ratio):
  class LTTextLineHorizontal (line 317) | class LTTextLineHorizontal(LTTextLine):
    method __init__ (line 319) | def __init__(self):
    method _insert_anon_spaces (line 323) | def _insert_anon_spaces(self, word_margin):
    method add (line 336) | def add(self, obj):
    method find_neighbors (line 340) | def find_neighbors(self, plane, ratio):
    method median_charheight (line 352) | def median_charheight(self):
  class LTTextLineVertical (line 362) | class LTTextLineVertical(LTTextLine):
    method _insert_anon_spaces (line 364) | def _insert_anon_spaces(self, word_margin):
    method find_neighbors (line 373) | def find_neighbors(self, plane, ratio):
  class LTTextBox (line 382) | class LTTextBox(LTTextContainer):
    method __init__ (line 384) | def __init__(self):
    method __repr__ (line 388) | def __repr__(self):
  class LTTextBoxHorizontal (line 393) | class LTTextBoxHorizontal(LTTextBox):
    method __init__ (line 395) | def __init__(self):
    method add (line 399) | def add(self, obj):
    method analyze (line 403) | def analyze(self, laparams):
    method _pos_in_box (line 407) | def _pos_in_box(self, obj):
    method _sort_lines (line 417) | def _sort_lines(self):
    method get_writing_mode (line 429) | def get_writing_mode(self):
    method paragraphs (line 432) | def paragraphs(self, indent_treshold):
  class LTTextBoxVertical (line 462) | class LTTextBoxVertical(LTTextBox):
    method analyze (line 464) | def analyze(self, laparams):
    method get_writing_mode (line 468) | def get_writing_mode(self):
  class LTTextGroup (line 472) | class LTTextGroup(LTTextContainer):
    method __init__ (line 474) | def __init__(self, objs):
  class LTTextGroupLRTB (line 478) | class LTTextGroupLRTB(LTTextGroup):
    method analyze (line 480) | def analyze(self, laparams):
  class LTTextGroupTBRL (line 487) | class LTTextGroupTBRL(LTTextGroup):
    method analyze (line 489) | def analyze(self, laparams):
  class LTLayoutContainer (line 497) | class LTLayoutContainer(LTContainer):
    method __init__ (line 499) | def __init__(self, bbox):
    method get_textlines (line 503) | def get_textlines(self, laparams, objs):
    method get_textboxes (line 567) | def get_textboxes(self, laparams, lines):
    method group_textboxes (line 597) | def group_textboxes(self, laparams, boxes):
    method analyze (line 657) | def analyze(self, laparams):
  class LTFigure (line 682) | class LTFigure(LTLayoutContainer):
    method __init__ (line 684) | def __init__(self, name, bbox, matrix):
    method __repr__ (line 692) | def __repr__(self):
    method analyze (line 697) | def analyze(self, laparams):
  class LTPage (line 703) | class LTPage(LTLayoutContainer):
    method __init__ (line 705) | def __init__(self, pageid, bbox, rotate=0):
    method __repr__ (line 710) | def __repr__(self):
  class Plane (line 722) | class Plane:
    method __init__ (line 724) | def __init__(self, objs=None, gridsize=50):
    method __repr__ (line 732) | def __repr__(self):
    method __iter__ (line 735) | def __iter__(self):
    method __len__ (line 738) | def __len__(self):
    method __contains__ (line 741) | def __contains__(self, obj):
    method _getrange (line 744) | def _getrange(self, area):
    method add (line 751) | def add(self, obj):
    method remove (line 762) | def remove(self, obj):
    method find (line 771) | def find(self, area):

FILE: pdfminer/lzw.py
  class CorruptDataError (line 8) | class CorruptDataError(Exception):
  class LZWDecoder (line 11) | class LZWDecoder:
    method __init__ (line 13) | def __init__(self, fp):
    method readbits (line 21) | def readbits(self, bits):
    method feed (line 45) | def feed(self, code):
    method run (line 80) | def run(self):
  function lzwdecode (line 95) | def lzwdecode(data):

FILE: pdfminer/pdfcolor.py
  class PDFColorSpace (line 10) | class PDFColorSpace:
    method __init__ (line 12) | def __init__(self, name, ncomponents):
    method __repr__ (line 16) | def __repr__(self):

FILE: pdfminer/pdfdevice.py
  class PDFDevice (line 7) | class PDFDevice:
    method __init__ (line 9) | def __init__(self, rsrcmgr):
    method __repr__ (line 13) | def __repr__(self):
    method close (line 16) | def close(self):
    method set_ctm (line 19) | def set_ctm(self, ctm):
    method begin_tag (line 22) | def begin_tag(self, tag, props=None):
    method end_tag (line 24) | def end_tag(self):
    method do_tag (line 26) | def do_tag(self, tag, props=None):
    method begin_page (line 29) | def begin_page(self, page, ctm):
    method end_page (line 31) | def end_page(self, page):
    method begin_figure (line 33) | def begin_figure(self, name, bbox, matrix):
    method end_figure (line 35) | def end_figure(self, name):
    method paint_path (line 38) | def paint_path(self, graphicstate, stroke, fill, evenodd, path):
    method render_image (line 40) | def render_image(self, name, stream):
    method render_string (line 42) | def render_string(self, textstate, seq):
  class PDFTextDevice (line 46) | class PDFTextDevice(PDFDevice):
    method render_string (line 48) | def render_string(self, textstate, seq):
    method render_string_horizontal (line 68) | def render_string_horizontal(self, seq, matrix, point, font, fontsize,...
    method render_string_vertical (line 87) | def render_string_vertical(self, seq, matrix, point, font, fontsize, s...
    method render_char (line 106) | def render_char(self, matrix, font, fontsize, scaling, rise, cid):
  class TagExtractor (line 110) | class TagExtractor(PDFDevice):
    method __init__ (line 112) | def __init__(self, rsrcmgr, outfp):
    method render_string (line 118) | def render_string(self, textstate, seq):
    method begin_page (line 133) | def begin_page(self, page, ctm):
    method end_page (line 137) | def end_page(self, page):
    method begin_tag (line 141) | def begin_tag(self, tag, props=None):
    method end_tag (line 149) | def end_tag(self):
    method do_tag (line 154) | def do_tag(self, tag, props=None):

FILE: pdfminer/pdffont.py
  function get_widths (line 18) | def get_widths(seq):
  function get_widths2 (line 40) | def get_widths2(seq):
  class FontMetricsDB (line 63) | class FontMetricsDB:
    method get_metrics (line 66) | def get_metrics(klass, fontname):
  class Type1FontHeaderParser (line 70) | class Type1FontHeaderParser(PSStackParser):
    method __init__ (line 82) | def __init__(self, data):
    method get_encoding (line 86) | def get_encoding(self):
    method do_keyword (line 98) | def do_keyword(self, pos, token):
  function getdict (line 111) | def getdict(data):
  class CFFFont (line 152) | class CFFFont:
    class INDEX (line 235) | class INDEX:
      method __init__ (line 237) | def __init__(self, fp):
      method __repr__ (line 246) | def __repr__(self):
      method __len__ (line 249) | def __len__(self):
      method __getitem__ (line 252) | def __getitem__(self, i):
      method __iter__ (line 256) | def __iter__(self):
    method __init__ (line 259) | def __init__(self, name, fp):
    method getstr (line 338) | def getstr(self, sid):
  class TrueTypeFont (line 344) | class TrueTypeFont:
    class CMapNotFound (line 346) | class CMapNotFound(Exception): pass
    method __init__ (line 348) | def __init__(self, name, fp):
    method create_unicode_map (line 358) | def create_unicode_map(self):
  class PDFFontError (line 423) | class PDFFontError(PDFException): pass
  class PDFUnicodeNotDefined (line 424) | class PDFUnicodeNotDefined(PDFFontError): pass
  class PDFFont (line 430) | class PDFFont:
    method __init__ (line 432) | def __init__(self, descriptor, widths, default_width=None):
    method __repr__ (line 447) | def __repr__(self):
    method is_vertical (line 450) | def is_vertical(self):
    method is_multibyte (line 453) | def is_multibyte(self):
    method decode (line 456) | def decode(self, s):
    method get_ascent (line 462) | def get_ascent(self):
    method get_descent (line 464) | def get_descent(self):
    method get_width (line 467) | def get_width(self):
    method get_height (line 472) | def get_height(self):
    method char_width (line 478) | def char_width(self, cid):
    method char_disp (line 481) | def char_disp(self, cid):
    method string_width (line 484) | def string_width(self, s):
  class PDFSimpleFont (line 488) | class PDFSimpleFont(PDFFont):
    method __init__ (line 490) | def __init__(self, descriptor, widths, spec):
    method to_unichr (line 511) | def to_unichr(self, cid):
  class PDFType1Font (line 522) | class PDFType1Font(PDFSimpleFont):
    method __init__ (line 524) | def __init__(self, rsrcmgr, spec):
    method __repr__ (line 547) | def __repr__(self):
  class PDFTrueTypeFont (line 550) | class PDFTrueTypeFont(PDFType1Font):
    method __repr__ (line 552) | def __repr__(self):
  class PDFType3Font (line 555) | class PDFType3Font(PDFSimpleFont):
    method __init__ (line 557) | def __init__(self, rsrcmgr, spec):
    method __repr__ (line 572) | def __repr__(self):
  class PDFCIDFont (line 576) | class PDFCIDFont(PDFFont):
    method __init__ (line 578) | def __init__(self, rsrcmgr, spec):
    method __repr__ (line 641) | def __repr__(self):
    method is_vertical (line 644) | def is_vertical(self):
    method is_multibyte (line 647) | def is_multibyte(self):
    method decode (line 650) | def decode(self, bytes):
    method char_disp (line 653) | def char_disp(self, cid):
    method to_unichr (line 657) | def to_unichr(self, cid):
  function main (line 666) | def main(argv):

FILE: pdfminer/pdfinterp.py
  class PDFResourceError (line 24) | class PDFResourceError(PDFException): pass
  class PDFInterpreterError (line 25) | class PDFInterpreterError(PDFException): pass
  class PDFTextState (line 37) | class PDFTextState:
    method __init__ (line 39) | def __init__(self):
    method __repr__ (line 52) | def __repr__(self):
    method copy (line 60) | def copy(self):
    method reset (line 74) | def reset(self):
  class PDFGraphicState (line 79) | class PDFGraphicState:
    method __init__ (line 81) | def __init__(self):
    method copy (line 90) | def copy(self):
    method __repr__ (line 101) | def __repr__(self):
  class PDFResourceManager (line 107) | class PDFResourceManager:
    method __init__ (line 114) | def __init__(self, caching=True):
    method get_procset (line 118) | def get_procset(self, procs):
    method get_cmap (line 128) | def get_cmap(self, cmapname, strict=False):
    method get_font (line 135) | def get_font(self, objid, spec):
  class PDFContentParser (line 177) | class PDFContentParser(PSStackParser):
    method __init__ (line 179) | def __init__(self, streams):
    method get_inline_data (line 190) | def get_inline_data(self, pos, target='EI'):
    method flush (line 214) | def flush(self):
    method do_keyword (line 220) | def do_keyword(self, pos, token):
  class PDFPageInterpreter (line 240) | class PDFPageInterpreter:
    method __init__ (line 242) | def __init__(self, rsrcmgr, device):
    method dup (line 246) | def dup(self):
    method init_resources (line 251) | def init_resources(self, resources):
    method init_state (line 292) | def init_state(self, ctm):
    method push (line 307) | def push(self, obj):
    method pop (line 310) | def pop(self, n):
    method get_current_state (line 317) | def get_current_state(self):
    method set_current_state (line 320) | def set_current_state(self, state):
    method do_q (line 325) | def do_q(self):
    method do_Q (line 328) | def do_Q(self):
    method do_cm (line 333) | def do_cm(self, a1, b1, c1, d1, e1, f1):
    method do_w (line 338) | def do_w(self, linewidth):
    method do_J (line 341) | def do_J(self, linecap):
    method do_j (line 344) | def do_j(self, linejoin):
    method do_M (line 347) | def do_M(self, miterlimit):
    method do_d (line 350) | def do_d(self, dash, phase):
    method do_ri (line 353) | def do_ri(self, intent):
    method do_i (line 356) | def do_i(self, flatness):
    method do_gs (line 359) | def do_gs(self, name):
    method do_m (line 364) | def do_m(self, x, y):
    method do_l (line 367) | def do_l(self, x, y):
    method do_c (line 370) | def do_c(self, x1, y1, x2, y2, x3, y3):
    method do_v (line 373) | def do_v(self, x2, y2, x3, y3):
    method do_y (line 376) | def do_y(self, x1, y1, x3, y3):
    method do_h (line 379) | def do_h(self):
    method do_re (line 382) | def do_re(self, x, y, w, h):
    method do_S (line 390) | def do_S(self):
    method do_s (line 394) | def do_s(self):
    method do_f (line 398) | def do_f(self):
    method do_f_a (line 404) | def do_f_a(self):
    method do_B (line 408) | def do_B(self):
    method do_B_a (line 412) | def do_B_a(self):
    method do_b (line 416) | def do_b(self):
    method do_b_a (line 420) | def do_b_a(self):
    method do_n (line 424) | def do_n(self):
    method do_W (line 427) | def do_W(self):
    method do_W_a (line 430) | def do_W_a(self):
    method do_CS (line 434) | def do_CS(self, name):
    method do_cs (line 437) | def do_cs(self, name):
    method do_G (line 440) | def do_G(self, gray):
    method do_g (line 444) | def do_g(self, gray):
    method do_RG (line 448) | def do_RG(self, r, g, b):
    method do_rg (line 452) | def do_rg(self, r, g, b):
    method do_K (line 456) | def do_K(self, c, m, y, k):
    method do_k (line 460) | def do_k(self, c, m, y, k):
    method do_SCN (line 465) | def do_SCN(self):
    method do_scn (line 472) | def do_scn(self):
    method do_SC (line 479) | def do_SC(self):
    method do_sc (line 481) | def do_sc(self):
    method do_sh (line 485) | def do_sh(self, name):
    method do_BT (line 489) | def do_BT(self):
    method do_ET (line 492) | def do_ET(self):
    method do_BX (line 496) | def do_BX(self):
    method do_EX (line 499) | def do_EX(self):
    method do_MP (line 503) | def do_MP(self, tag):
    method do_DP (line 505) | def do_DP(self, tag, props):
    method do_BMC (line 507) | def do_BMC(self, tag):
    method do_BDC (line 509) | def do_BDC(self, tag, props):
    method do_EMC (line 511) | def do_EMC(self):
    method do_Tc (line 515) | def do_Tc(self, space):
    method do_Tw (line 518) | def do_Tw(self, space):
    method do_Tz (line 521) | def do_Tz(self, scale):
    method do_TL (line 524) | def do_TL(self, leading):
    method do_Tf (line 527) | def do_Tf(self, fontid, fontsize):
    method do_Tr (line 535) | def do_Tr(self, render):
    method do_Ts (line 538) | def do_Ts(self, rise):
    method do_Td (line 542) | def do_Td(self, tx, ty):
    method do_TD (line 548) | def do_TD(self, tx, ty):
    method do_Tm (line 555) | def do_Tm(self, a,b,c,d,e,f):
    method do_T_a (line 559) | def do_T_a(self):
    method do_TJ (line 565) | def do_TJ(self, seq):
    method do_Tj (line 572) | def do_Tj(self, s):
    method do__q (line 575) | def do__q(self, s):
    method do__w (line 579) | def do__w(self, aw, ac, s):
    method do_BI (line 585) | def do_BI(self): # never called
    method do_ID (line 587) | def do_ID(self): # never called
    method do_EI (line 589) | def do_EI(self, obj):
    method do_Do (line 602) | def do_Do(self, xobjid):
    method process_page (line 630) | def process_page(self, page):
    method render_contents (line 648) | def render_contents(self, resources, streams, ctm=MATRIX_IDENTITY):
    method execute (line 654) | def execute(self, streams):
  class PDFTextExtractionNotAllowed (line 685) | class PDFTextExtractionNotAllowed(PDFInterpreterError): pass
  function process_pdf (line 687) | def process_pdf(rsrcmgr, device, fp, pagenos=None, maxpages=0, password='',

FILE: pdfminer/pdfparser.py
  class PDFSyntaxError (line 19) | class PDFSyntaxError(PDFException): pass
  class PDFNoValidXRef (line 20) | class PDFNoValidXRef(PDFSyntaxError): pass
  class PDFNoOutlines (line 21) | class PDFNoOutlines(PDFException): pass
  class PDFDestinationNotFound (line 22) | class PDFDestinationNotFound(PDFException): pass
  class PDFAlreadyParsed (line 23) | class PDFAlreadyParsed(PDFException): pass
  class PDFEncryptionError (line 24) | class PDFEncryptionError(PDFException): pass
  class PDFPasswordIncorrect (line 25) | class PDFPasswordIncorrect(PDFEncryptionError): pass
  class PDFBaseXRef (line 35) | class PDFBaseXRef:
    method get_trailer (line 37) | def get_trailer(self):
    method get_objids (line 40) | def get_objids(self):
    method get_pos (line 43) | def get_pos(self, objid):
  class PDFXRef (line 47) | class PDFXRef(PDFBaseXRef):
    method __init__ (line 49) | def __init__(self):
    method load (line 53) | def load(self, parser):
    method load_trailer (line 87) | def load_trailer(self, parser):
    method load_fallback (line 101) | def load_fallback(self, parser, debug=0):
    method get_trailer (line 118) | def get_trailer(self):
    method get_objids (line 121) | def get_objids(self):
    method get_pos (line 124) | def get_pos(self, objid):
  class PDFXRefStream (line 132) | class PDFXRefStream(PDFBaseXRef):
    method __init__ (line 134) | def __init__(self):
    method __repr__ (line 140) | def __repr__(self):
    method load (line 143) | def load(self, parser):
    method get_trailer (line 164) | def get_trailer(self):
    method get_objids (line 167) | def get_objids(self):
    method get_pos (line 172) | def get_pos(self, objid):
  class PDFPage (line 198) | class PDFPage:
    method __init__ (line 220) | def __init__(self, doc, pageid, attrs):
    method __repr__ (line 248) | def __repr__(self):
  class PDFDocument (line 252) | class PDFDocument:
    method __init__ (line 269) | def __init__(self, caching=True):
    method _parse_next_object (line 281) | def _parse_next_object(self, parser):
    method _parse_objstream (line 294) | def _parse_objstream(self, stream):
    method _parse_whole (line 311) | def _parse_whole(self, parser):
    method _parse_everything (line 322) | def _parse_everything(self):
    method _getobj (line 335) | def _getobj(self, objid):
    method set_parser (line 417) | def set_parser(self, parser):
    method initialize (line 449) | def initialize(self, password=''):
    method decrypt_rc4 (line 506) | def decrypt_rc4(self, objid, genno, data):
    method readobj (line 512) | def readobj(self):
    method find_obj_ref (line 520) | def find_obj_ref(self, objid):
    method getobj (line 531) | def getobj(self, objid):
    method get_pages (line 542) | def get_pages(self):
    method get_outlines (line 571) | def get_outlines(self):
    method lookup_name (line 591) | def lookup_name(self, cat, key):
    method get_dest (line 613) | def get_dest(self, name):
  class PDFParser (line 628) | class PDFParser(PSStackParser):
    method __init__ (line 645) | def __init__(self, fp):
    method set_document (line 650) | def set_document(self, doc):
    method do_keyword (line 660) | def do_keyword(self, pos, token):
    method find_xref (line 719) | def find_xref(self):
    method read_xref_from (line 733) | def read_xref_from(self, start, xrefs):
    method read_xref (line 765) | def read_xref(self):
  class PDFStreamParser (line 781) | class PDFStreamParser(PDFParser):
    method __init__ (line 791) | def __init__(self, data):
    method flush (line 794) | def flush(self):
    method do_keyword (line 797) | def do_keyword(self, pos, token):

FILE: pdfminer/pdftypes.py
  class PDFObject (line 24) | class PDFObject(PSObject): pass
  class PDFException (line 26) | class PDFException(PSException): pass
  class PDFTypeError (line 27) | class PDFTypeError(PDFException): pass
  class PDFValueError (line 28) | class PDFValueError(PDFException): pass
  class PDFNotImplementedError (line 29) | class PDFNotImplementedError(PSException): pass
  class PDFObjRef (line 34) | class PDFObjRef(PDFObject):
    method __init__ (line 36) | def __init__(self, doc, objid, _):
    method __repr__ (line 43) | def __repr__(self):
    method resolve (line 46) | def resolve(self):
  function resolve1 (line 51) | def resolve1(x):
  function resolve_all (line 61) | def resolve_all(x):
  function decipher_all (line 76) | def decipher_all(decipher, objid, genno, x):
  function typecheck_value (line 91) | def typecheck_value(x, type, strict=STRICT):
  function stream_value (line 106) | def stream_value(x):
  class PDFStream (line 114) | class PDFStream(PDFObject):
    method __init__ (line 116) | def __init__(self, attrs, rawdata, decipher=None):
    method set_objid (line 125) | def set_objid(self, objid, genno):
    method __repr__ (line 129) | def __repr__(self):
    method __contains__ (line 137) | def __contains__(self, name):
    method __getitem__ (line 140) | def __getitem__(self, name):
    method get (line 143) | def get(self, name, default=None):
    method get_any (line 146) | def get_any(self, names, default=None):
    method get_filters (line 152) | def get_filters(self):
    method decode (line 158) | def decode(self):
    method get_data (line 223) | def get_data(self):
    method get_rawdata (line 228) | def get_rawdata(self):

FILE: pdfminer/pslexer.py
  function t_COMMENT (line 15) | def t_COMMENT(t):
  function t_HEXSTRING (line 23) | def t_HEXSTRING(t):
  function t_INT (line 35) | def t_INT(t):
  function t_FLOAT (line 40) | def t_FLOAT(t):
  function t_LITERAL (line 46) | def t_LITERAL(t):
  function t_OPERATOR (line 58) | def t_OPERATOR(t):
  function t_instring (line 64) | def t_instring(t):
  function t_instring_lparen (line 78) | def t_instring_lparen(t):
  function t_instring_rparen (line 87) | def t_instring_rparen(t):
  function repl_string_escape (line 111) | def repl_string_escape(m):
  function repl_string_octal (line 114) | def repl_string_octal(m):
  function t_instring_contents (line 121) | def t_instring_contents(t):
  function t_error (line 133) | def t_error(t):

FILE: pdfminer/psparser.py
  class PSException (line 12) | class PSException(Exception): pass
  class PSEOF (line 13) | class PSEOF(PSException): pass
  class PSSyntaxError (line 14) | class PSSyntaxError(PSException): pass
  class PSTypeError (line 15) | class PSTypeError(PSException): pass
  class PSValueError (line 16) | class PSValueError(PSException): pass
  function handle_error (line 18) | def handle_error(exctype, msg, strict=STRICT):
  class PSObject (line 27) | class PSObject:
  class PSLiteral (line 32) | class PSLiteral(PSObject):
    method __init__ (line 45) | def __init__(self, name):
    method __repr__ (line 48) | def __repr__(self):
  class PSKeyword (line 52) | class PSKeyword(PSObject):
    method __init__ (line 64) | def __init__(self, name):
    method __repr__ (line 67) | def __repr__(self):
  class PSSymbolTable (line 71) | class PSSymbolTable:
    method __init__ (line 78) | def __init__(self, klass):
    method intern (line 82) | def intern(self, name):
  function literal_name (line 102) | def literal_name(x):
  function keyword_name (line 108) | def keyword_name(x):
  class PSBaseParser (line 129) | class PSBaseParser:
    method __init__ (line 133) | def __init__(self, fp):
    method _convert_token (line 141) | def _convert_token(self, token):
    method flush (line 155) | def flush(self):
    method close (line 158) | def close(self):
    method setpos (line 163) | def setpos(self, newpos):
    method nextline (line 168) | def nextline(self):
    method nexttoken (line 177) | def nexttoken(self):
  class PSStackParser (line 185) | class PSStackParser(PSBaseParser):
    method __init__ (line 187) | def __init__(self, fp):
    method reset (line 191) | def reset(self):
    method setpos (line 197) | def setpos(self, newpos):
    method push (line 201) | def push(self, *objs):
    method pop (line 204) | def pop(self, n):
    method popall (line 209) | def popall(self):
    method add_results (line 214) | def add_results(self, *objs):
    method start_type (line 218) | def start_type(self, pos, type):
    method end_type (line 223) | def end_type(self, type):
    method do_keyword (line 231) | def do_keyword(self, pos, token):
    method nextobject (line 234) | def nextobject(self):

FILE: pdfminer/rijndael.py
  function KEYLENGTH (line 14) | def KEYLENGTH(keybits): return (keybits)//8
  function RKLENGTH (line 15) | def RKLENGTH(keybits): return (keybits)//8+28
  function NROUNDS (line 16) | def NROUNDS(keybits): return (keybits)//32+6
  function GETU32 (line 697) | def GETU32(x): return struct.unpack('>L', x)[0]
  function PUTU32 (line 698) | def PUTU32(x): return struct.pack('>L', x)
  function GETU32 (line 701) | def GETU32(x): return struct.unpack('>I', x)[0]
  function PUTU32 (line 702) | def PUTU32(x): return struct.pack('>I', x)
  function rijndaelSetupEncrypt (line 707) | def rijndaelSetupEncrypt(key, keybits):
  function rijndaelSetupDecrypt (line 783) | def rijndaelSetupDecrypt(key, keybits):
  function rijndaelEncrypt (line 825) | def rijndaelEncrypt(rk, nrounds, plaintext):
  function rijndaelDecrypt (line 928) | def rijndaelDecrypt(rk, nrounds, ciphertext):
  class RijndaelDecryptor (line 1032) | class RijndaelDecryptor:
    method __init__ (line 1033) | def __init__(self, key, keybits=256):
    method decrypt (line 1039) | def decrypt(self, ciphertext):
  class RijndaelEncryptor (line 1044) | class RijndaelEncryptor:
    method __init__ (line 1045) | def __init__(self, key, keybits=256):
    method encrypt (line 1051) | def encrypt(self, plaintext):

FILE: pdfminer/runlength.py
  function rldecode (line 11) | def rldecode(data):

FILE: pdfminer/utils.py
  function apply_png_predictor (line 7) | def apply_png_predictor(pred, colors, columns, bitspercomponent, data):
  function mult_matrix (line 57) | def mult_matrix(matrix1, matrix2):
  function translate_matrix (line 65) | def translate_matrix(matrix, point):
  function apply_matrix_pt (line 71) | def apply_matrix_pt(matrix, point):
  function apply_matrix_norm (line 77) | def apply_matrix_norm(matrix, norm):
  function uniq (line 88) | def uniq(objs):
  function fsplit (line 97) | def fsplit(pred, objs):
  function drange (line 109) | def drange(v0, v1, d):
  function get_bound (line 115) | def get_bound(pts):
  function pick (line 126) | def pick(seq, func, maxobj=None):
  function choplist (line 136) | def choplist(n, seq):
  function trailiter (line 145) | def trailiter(iterable, skipfirst=False):
  function nunpack (line 161) | def nunpack(b, default=0):
  function decode_text (line 214) | def decode_text(s):
  function htmlescape (line 221) | def htmlescape(s, encoding='ascii'):
  function bbox2str (line 229) | def bbox2str(bbox):
  function matrix2str (line 233) | def matrix2str(matrix):
  function set_debug_logging (line 237) | def set_debug_logging():
  class ObjIdRange (line 241) | class ObjIdRange:
    method __init__ (line 245) | def __init__(self, start, nobjs):
    method __repr__ (line 249) | def __repr__(self):
    method get_start_id (line 252) | def get_start_id(self):
    method get_end_id (line 255) | def get_end_id(self):
    method get_nobjs (line 258) | def get_nobjs(self):
  function create_bmp (line 263) | def create_bmp(data, bits, width, height):

FILE: tests/layout_test.py
  function test_small_elements_get_plane_grid_placement (line 8) | def test_small_elements_get_plane_grid_placement():
  function test_slightly_higher_text (line 15) | def test_slightly_higher_text():
  function test_paragraph_indents (line 24) | def test_paragraph_indents():
  function test_centered_text (line 35) | def test_centered_text():
  function test_big_letter_with_title (line 43) | def test_big_letter_with_title():
  function test_big_letter_spanning_multiple_lines (line 53) | def test_big_letter_spanning_multiple_lines():
  function test_space_chars_only (line 65) | def test_space_chars_only():

FILE: tests/parser_test.py
  function get_tokens (line 26) | def get_tokens(s):
  function get_objects (line 39) | def get_objects(s):
  function withoutpos (line 52) | def withoutpos(tokens):
  function test_tokens (line 55) | def test_tokens():
  function test_objects (line 73) | def test_objects():
  function test_byte_strings_are_parsed_as_bytes (line 88) | def test_byte_strings_are_parsed_as_bytes():
  function test_detect_escaped_parens_in_string (line 99) | def test_detect_escaped_parens_in_string():
  function test_true_false_keywords_translate_to_bool (line 106) | def test_true_false_keywords_translate_to_bool():
  function test_hexstring_without_delimiter (line 112) | def test_hexstring_without_delimiter():
  function test_octal_string_over_byte_value (line 119) | def test_octal_string_over_byte_value():

FILE: tests/samples_test.py
  function runcmd (line 13) | def runcmd(args):
  function pytest_generate_tests (line 19) | def pytest_generate_tests(metafunc):
  function test_convert_sample (line 42) | def test_convert_sample(samplepath, tmpdir):

FILE: tests/support_test.py
  function test_arcfour (line 8) | def test_arcfour():
  function test_ascii85decode (line 13) | def test_ascii85decode():
  function test_asciihexdecode (line 17) | def test_asciihexdecode():
  function test_lzwdecode (line 22) | def test_lzwdecode():
  function test_lzwdecode_garbage (line 25) | def test_lzwdecode_garbage():
  function test_lzwdecode_invalid (line 31) | def test_lzwdecode_invalid():
  function test_RijndaelDecryptor (line 36) | def test_RijndaelDecryptor():
  function test_RijndaelEncryptor (line 42) | def test_RijndaelEncryptor():
  function test_rldecode (line 48) | def test_rldecode():
  function test_nunpack (line 52) | def test_nunpack():
  function test_trailiter (line 63) | def test_trailiter():

FILE: tests/util.py
  function eq_ (line 8) | def eq_(a, b, msg=None):
  class TestData (line 12) | class TestData:
    method __init__ (line 13) | def __init__(self, datadirpath):
    method filepath (line 16) | def filepath(self, relative_path, *args):
  function pages_from_pdf (line 28) | def pages_from_pdf(path, **laparams):
  function extract_from_elem (line 46) | def extract_from_elem(elem, lookfor):
  function extract_textboxes (line 55) | def extract_textboxes(elem):

FILE: tools/conv_afm.py
  function main (line 5) | def main(argv):

FILE: tools/conv_cmap.py
  function process_cid2code (line 7) | def process_cid2code(fp, check_codecs=[]):
  function main (line 115) | def main(argv):

FILE: tools/conv_glyphlist.py
  function main (line 5) | def main(argv):

FILE: tools/dumppdf.py
  function e (line 17) | def e(s):
  function dumpxml (line 22) | def dumpxml(out, obj, codec=None):
  function dumptrailers (line 85) | def dumptrailers(out, doc):
  function dumpallobjs (line 92) | def dumpallobjs(out, doc, codec=None):
  function dumpoutline (line 108) | def dumpoutline(outfp, fname, objids, pagenos, password='',
  function dumppdf (line 156) | def dumppdf(outfp, fname, objids, pagenos, password='',
  function main (line 187) | def main(argv):

FILE: tools/latin2ascii.py
  function latin2ascii (line 108) | def latin2ascii(s):
  function main (line 112) | def main(argv):

FILE: tools/pdf2txt.py
  function main (line 12) | def main(argv):

FILE: tools/pdfexplore.py
  class bcolors (line 8) | class bcolors:
  function intarg (line 16) | def intarg(default=None):
  class PDFExploreCmd (line 29) | class PDFExploreCmd(cmd.Cmd):
    method __init__ (line 32) | def __init__(self, pdf_path):
    method _cached_objects (line 44) | def _cached_objects(self):
    method _get_refs (line 47) | def _get_refs(self):
    method precmd (line 63) | def precmd(self, line):
    method do_debug (line 68) | def do_debug(self, arg):
    method do_status (line 75) | def do_status(self, arg):
    method do_xref (line 86) | def do_xref(self, arg):
    method do_setpos (line 104) | def do_setpos(self, arg):
    method do_rtok (line 110) | def do_rtok(self, arg):
    method do_ptok (line 127) | def do_ptok(self, arg):
    method do_robj (line 133) | def do_robj(self, arg):
    method do_sobj (line 140) | def do_sobj(self, arg):
    method do_dbgobj (line 159) | def do_dbgobj(self, arg):
    method do_readall (line 167) | def do_readall(self, arg):
    method do_dumpdata (line 173) | def do_dumpdata(self, arg):
    method do_whatisread (line 182) | def do_whatisread(self, arg):
    method do_refs (line 187) | def do_refs(self, arg):
    method do_deadrefs (line 197) | def do_deadrefs(self, arg):
    method do_quit (line 204) | def do_quit(self, arg):
  function parse_args (line 211) | def parse_args():

FILE: tools/prof.py
  function prof_main (line 4) | def prof_main(argv):

FILE: tools/runapp.py
  class WebAppHandler (line 17) | class WebAppHandler(SimpleHTTPRequestHandler):
    method do_POST (line 21) | def do_POST(self):
    method send_head (line 24) | def send_head(self):
    method run_cgi (line 27) | def run_cgi(self):
  function main (line 87) | def main(argv):