/j-jRSrSSKrSSKrSSKJr SSKJr SSKJr SSKJ r SSK J r SS K J r SS K J r S rSS jrS rSrSS\4SjjrSrg)zBIO related functions to Read the PDF and returns extracted tables.N)Any) TableList)FilepathOrBuffer) PDFHandler)TemporaryDirectory) remove_extra)validate_inputcl^^^ ^ ^ SSKJm SSKJm SSKJm U U UU U4SjnUc:[ 5nU"[ RRUS55nSSS5 O U"U5nWcgUupxU[:=(a U[:n U (aS $S$!,(df  N:=f![a gf=f) uPick the most appropriate flavor for a single PDF page. Renders ``page``, thresholds it, and counts ruled horizontal and vertical line segments. Used when the caller passes ``flavor="auto"`` (once per requested page, so a document with text-only cover pages and ruled tables deeper in is routed correctly per page). Returns ------- str Either ``"lattice"`` (enough ruled lines on the rendered page) or ``"network"`` (else). ``"network"`` is also the fallback when rendering itself fails (e.g. unreadable PDF, missing backend dependencies) — the assumption is that giving the text-based parser a chance is more useful than raising before parsing starts. r)ImageConversionBackend)adaptive_threshold) find_linesc>T"5R[T5UT S9 [RR U5(dgT"USS9upT"USSS9upT"USSS9up[ U5[ U54$)N)pageF)process_backgroundvertical) direction line_scale horizontal)convertstrospathexistslen) target_png_ thresholdvhr rfilepathrrs G/home/mande/repo/quber/.venv/lib/python3.13/site-packages/camelot/io.py_probe_detect_flavor.._probe.sy  ((X (Nww~~j)))*O )zbI)|K1vs1v~Nzauto_flavor_probe.pngnetworklattice) backendsr image_processingrrrrrjoin Exception_AUTO_FLAVOR_LINE_THRESHOLD) r#passwordrpng_pathr%tmpdircountsv_counth_counthas_gridr rrs ` ` @@@r$_detect_flavorr6s(14,    #% V5L MN&% H%F~G.. 3 2 2 !9/i/)&%   s4 B&'BB& B& B#B&#B&& B32B3c <Uc0$0nUR5HXup#[U5n[ U[ 5(d%[SU<S[ U5R35e[ U5X'MZ U$![[4an[SU<35UeSnAff=f)aBCoerce ``per_page`` to ``{int: dict}`` form, raising ValueError on bad input. Accepts None / empty (returns ``{}``), int or str keys, and dict values. Other shapes raise ``ValueError`` with a precise message naming the offending entry. Values are shallow-copied so a later in-place edit doesn't mutate the caller's dict. Nz(per_page keys must be page numbers, got per_page[z ] must be a dict of kwargs, got )itemsint TypeError ValueError isinstancedicttype__name__)per_page per_page_normkr!page_noexcs r$_normalize_per_pagerFWs /1M  X!fG!T""A5 @aAQAQ@RS "&a ! :& XGuMNTW W Xs A66BBBcUR5Heup#URSU5nUS;a[SUSU<S35eUR5VVs0sHupVUS:wdM XV_M nnn[XtS9 Mg gs snnf)uQValidate each per-page override against its effective flavor. Each entry's flavor is either an explicit override (must be one of the four concrete flavors — ``"auto"`` doesn't make sense page-by-page) or the global flavor. All non-flavor kwargs are then checked with the existing :func:`validate_input` against that effective flavor. flavor)r)streamr(hybridmlr8z ] flavor=zl is not one of: 'lattice', 'stream', 'network', 'hybrid', 'ml'. ('auto' is only valid as the global flavor.)rHN)r9getNotImplementedErrorr )rB global_flavorrD overrides page_flavorrCr! page_kwargss r$_validate_per_pagerSos,113mmHm< N N%G9Ik_=@@  )2(9K(9Q(]tqt(9 K{74Ls  A;$A;r#c Uc0nUS;a [S5e[U5n [R"5 U(a[R"S5 [ XX)S9n US:Xa![ U U UUUUU S9sSSS5 sSSS5 $[XS9 [XS9n [X5 U R"S UUUUUU S .U D6n SSS5 W sSSS5 $!,(df  N=f!,(df  g=f) u(Read PDF and return extracted tables. Note: kwargs annotated with ^ can only be used with flavor='stream' or flavor='network' and kwargs annotated with * can only be used with flavor='lattice'. The hybrid parser accepts kwargs with both annotations. Parameters ---------- filepath : str, Path, bytes, or binary file-like Source PDF. Accepts a filesystem path / URL, a ``bytes``-like object, or any binary stream with a ``.read()`` method (``io.BytesIO``, an open ``"rb"`` file, ``requests`` response ``.raw``, etc). For in-memory inputs the bytes are spilled to a temporary file once and cleaned up on context-manager exit, so the Lattice OpenCV image-conversion backend keeps working unchanged. Originally requested in #170 / #245 / #270. pages : str, optional (default: '1') Comma-separated page numbers. Example: '1,3,4' or '1,4-end' or 'all'. password : str, optional (default: None) Password for decryption. flavor : str (default: 'lattice') The parsing method to use. Valid values: - ``'lattice'`` (default): line-ruled tables. - ``'stream'``: borderless tables with whitespace-separated columns. - ``'network'``: borderless tables via text-edge alignment connectivity. - ``'hybrid'``: combines layout- and image-based analysis. - ``'ml'``: neural table-structure recognition (Table Transformer) for the structure, with cell text filled from the PDF's own text layer (no hallucinated values). Requires the optional ML dependencies: ``pip install 'camelot-py[ml]'``. Best for borderless tables where the heuristic parsers plateau. - ``'auto'``: detect the flavor **per page** (count ruled lines on each rendered page) and parse each group accordingly — ruled pages via ``lattice`` with ``engine='combined'``, the rest via ``network`` — then merge. Handles documents that mix text-only cover pages with ruled tables deeper in. A ``UserWarning`` reports the per-page choices. (More accurate but slower, since it renders every page for the probe.) suppress_stdout : bool, optional (default: False) Print all logs and warnings. parallel : bool, optional (default: False) Process pages in parallel using all available cpu cores. cpu_count : int, optional (default: None) Maximum number of worker processes when ``parallel=True``. ``None`` (default) uses all available cores. Values are clamped to ``[1, multiprocessing.cpu_count()]``. Ignored when ``parallel=False``. layout_kwargs : dict, optional (default: {}) A dict of `pdfminer.layout.LAParams `_ kwargs. per_page : dict, optional (default: None) Per-page parameter overrides. Maps a 1-indexed page number (int or str) to a dict of any keyword argument otherwise valid for ``read_pdf``. Values supplied here override the globally-supplied kwargs for that one page only — every other page keeps the global values. Useful for multi-layout PDFs where different pages need different ``table_areas``, ``columns``, ``flavor``, etc. The per-page ``flavor`` itself may be overridden; the global flavor applies otherwise. Originally proposed by @sverma25 in #41. Example:: tables = camelot.read_pdf( "report.pdf", pages="1-3", flavor="stream", split_text=True, per_page={2: {"table_areas": ["120, 210, 400, 90"]}}, ) Here pages 1 and 3 use the global ``flavor="stream", split_text=True`` only; page 2 uses both *and* the page-specific ``table_areas``. table_areas : list, optional (default: None) List of table area strings of the form x1,y1,x2,y2 where (x1, y1) -> left-top and (x2, y2) -> right-bottom in PDF coordinate space. columns^ : list, optional (default: None) List of column x-coordinates strings where the coordinates are comma-separated. split_text : bool, optional (default: False) Split text that spans across multiple cells. flag_size : bool, optional (default: False) Flag text based on font size. Useful to detect super/subscripts. Adds around flagged text. strip_text : str or sequence of str, optional (default: '') Characters or substrings to strip from each cell before assignment. A ``str`` strips per-character — every character in the string is removed wherever it appears (e.g. ``" \n"`` drops all spaces and newlines). A list/tuple of ``str`` strips whole substrings (e.g. ``["[1]", "[2]"]`` removes those footnote markers but leaves bare ``[``/``]`` alone). Whole-substring mode requested in #484. replace_text : dict, optional (default: None) Mapping of substring → replacement applied to every cell's text just before it is written into the table. Keys are matched as literal substrings (regex metacharacters are escaped). Useful for collapsing soft-broken words (e.g. ``{" \n": " "}``), normalising abbreviations, or rewriting unit names. Distinct from ``strip_text`` which can only remove characters; this can replace with arbitrary text. Requested in #481. (#482) row_tol^ : int, optional (default: 2) Tolerance parameter used to combine text vertically, to generate rows. column_tol^ : int, optional (default: 0) Tolerance parameter used to combine text horizontally, to generate columns. process_background* : bool, optional (default: False) Process background lines. line_scale* : int, optional (default: 15) Line size scaling factor. The larger the value the smaller the detected lines. Making it very large will lead to text being detected as lines. copy_text* : list, optional (default: None) {'h', 'v'} Direction in which text in a spanning cell will be copied over. shift_text* : list, optional (default: ['l', 't']) {'l', 'r', 't', 'b'} Direction in which text in a spanning cell will flow. line_tol* : int, optional (default: 2) Tolerance parameter used to merge close vertical and horizontal lines. joint_tol* : int, optional (default: 2) Tolerance parameter used to decide whether the detected lines and points lie close to each other. threshold_blocksize* : int, optional (default: 15) Size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on. For more information, refer `OpenCV's adaptiveThreshold `_. threshold_constant* : int, optional (default: -2) Constant subtracted from the mean or weighted mean. Normally, it is positive but may be zero or negative as well. For more information, refer `OpenCV's adaptiveThreshold `_. iterations* : int, optional (default: 0) Number of dilation passes applied to close small gaps in the line mask. For more information, refer `OpenCV's dilate `_. erode_iterations* : int, optional (default: 0) Number of erosion passes applied **after** dilation. Set equal to ``iterations`` for a morphological closing — bridges gaps in ruled lines without thickening the mask overall (which avoids the spurious extra-row artefact reported in #363). (#363) backend* : str, optional by default "pdfium" The backend to use for converting the PDF to an image so it can be processed by OpenCV. use_fallback* : bool, optional Fallback to another backend if unavailable, by default True resolution* : int, optional (default: 300) Resolution used for PDF to PNG conversion. engine* : str, optional (default: 'combined') Line-detection engine for ``flavor='lattice'`` (and the lattice half of ``flavor='hybrid'``): - ``'combined'`` (default): render the page and detect ruled lines with OpenCV **and** union in the ruled lines read from the PDF's native vector graphics, so tables whose rules render faintly (vector strokes, anti-aliasing) are still found. Safe by construction — raster always runs, vector lines can only add, and they're clipped to ``table_regions`` — so it never does worse than ``'raster'`` (#763). - ``'raster'``: render the page and detect ruled lines with OpenCV only — the pre-#763 behaviour. - ``'vector'``: detect tables straight from the PDF's vector ruled lines, skipping rasterisation entirely — the fastest path, for PDFs whose tables are drawn with real vector strokes (#763). With ``flavor='hybrid'`` the same choices select how its lattice half finds ruled lines; ``engine='vector'`` there is the **render-free hybrid** — vector ruled lines merged with the network text-edge alignment — for partial-ruled / borderless tables at roughly an order of magnitude less time than the raster path (#39). Returns ------- tables : camelot.core.TableList Notes ----- **Encrypted PDFs / extraction permissions** (#590). Camelot honours the ``/Encrypt`` dictionary's text-extraction permission: ``read_pdf`` raises :class:`playa.exceptions.PDFTextExtractionNotAllowed` if the PDF is encrypted and the user-password permission set forbids text extraction. The check fires on the document object returned by ``playa.open`` while the encryption metadata is still attached — this is a real behavioural change vs the pre-1.0 backend, where per-page temp-PDF splitting silently dropped the metadata so the check was effectively a no-op. Note: PDF spec only enforces the flag through the encryption layer — for **unencrypted** PDFs that carry a "no extraction" claim via ``/Perms``, there is no enforcement mechanism and Camelot extracts. Supplying the document owner password through ``password=`` bypasses the user-password permission set (matches every other PDF tool). Examples -------- >>> import camelot >>> tables = camelot.read_pdf("foo.pdf") # xdoctest: +SKIP >>> tables.n # xdoctest: +SKIP 1 >>> tables[0].df # xdoctest: +SKIP >>> tables[0].to_csv("foo.csv") # xdoctest: +SKIP Select a parser and restrict extraction to a page range: >>> tables = camelot.read_pdf( # xdoctest: +SKIP ... "foo.pdf", flavor="lattice", pages="1-3" ... ) N)r)rIr(rJrKautoz]Unknown flavor specified. Use either 'lattice', 'stream', 'network', 'hybrid', 'ml' or 'auto'ignore)pagesr/debugrU)suppress_stdoutparallel cpu_count layout_kwargsrBrL)rHrYrZr[r\rA) rNrFwarningscatch_warnings simplefilterr _parse_autor r rSparse)r#rWr/rHrYrZr[r\rArXkwargsrBptabless r$read_pdfrfs J  MM! S  (1M  "   ! !( +  NRS"$3%'"/"/O N # " 6 1!&8F } 5WW /!#+& F!O2; # "O N # "s/(C!C4 C!6C= C! C C!! C/c2^[5n0n0n URHn [RR USU S35n [ UR UR=(d SU U S9mTX'TS:XdM\[RRU 5(dMXU 'M [R"SU3[SS9 /n S Hm[U4S jUR555n U (dM/[[U5TS 9nTS:XaUR!S S 5 [#UT5 U R%UR&"STUUUUUU TS:XaU OSS.UD65 M U R)SS9 [+U 5sSSS5 $!,(df  g=f)uwParse with ``flavor='auto'`` — flavor detected **per page**. Each requested page is probed independently (so a document with a text-only cover and ruled tables deeper in is routed correctly), then pages are grouped by detected flavor and parsed in one pass per group: ruled pages via ``lattice`` with ``engine='combined'`` (the most accurate detector), the rest via ``network``. Results are merged into a single page/order-sorted :class:`~camelot.core.TableList`. The page rendered for each lattice page's probe is kept and handed to the parser via ``render_cache``, so that page isn't rasterised a second time during parsing. zauto-probe-page-z.pngN)r/rr0r)z1camelot.read_pdf: auto-detected per-page flavors ) stacklevel)r)r(c3<># UHupUT:XdM Uv M g7fNr]).0pgffls r$ _parse_auto..s P1DR1Ds  rLenginecombined)rHrYrZr[r\rArW render_cachec2URUR4$rk)rorder)ts r$_parse_auto..saffagg%6r')keyr])rrWrrr,r6r#r/rr^warn UserWarningsortedr9r r> setdefaultrSextendrbsortr)handlerrcrYrZr[r\rB cache_dirrQrtrm probe_png collected group_pages group_kwargsros @r$raras.   ') --B Y2B2$d0KLI   ))1T" B !KOY277>>)#<#<#,R    ? } M   (B P1B1B1D PPK'V R@LY''*= }b 1    $3%'"/*%13yd #  )0 67#]   sA)F9"FCF F)NrN) 1Nr)FFNNNF)__doc__rr^typingrcorerhandlersrrutilsrr r r.r6rFrSrfrar]r'r$rsnH & %! >0B08.      LL^E$r'