doctra 0.3.3__py3-none-any.whl → 0.4.1__py3-none-any.whl

doctra/third_party/docres/utils.py

@@ -0,0 +1,464 @@
+from collections import OrderedDict
+import os
+import numpy as np
+import torch
+import torch.nn.functional as F
+import os 
+from skimage.filters import threshold_sauvola
+import cv2 
+
+def second2hours(seconds):
+    h = seconds//3600
+    seconds %= 3600
+    m = seconds//60
+    seconds %= 60
+
+    hms = '{:d} H : {:d} Min'.format(int(h),int(m))
+    return hms
+
+
+def dict2string(loss_dict):
+    loss_string = ''
+    for key, value in loss_dict.items():
+        loss_string += key+' {:.4f}, '.format(value)
+    return loss_string[:-2]
+def mkdir(dir):
+    if not os.path.exists(dir):
+        os.makedirs(dir)    
+
+def convert_state_dict(state_dict):
+    """Converts a state dict saved from a dataParallel module to normal 
+       module state_dict inplace
+       :param state_dict is the loaded DataParallel model_state
+    
+    """
+    new_state_dict = OrderedDict()
+    for k, v in state_dict.items():
+        name = k[7:] # remove `module.`
+        new_state_dict[name] = v
+    return new_state_dict
+
+
+def get_lr(optimizer):
+    for param_group in optimizer.param_groups:
+        return float(param_group['lr'])
+
+
+def torch2cvimg(tensor,min=0,max=1):
+    '''
+    input:
+        tensor -> torch.tensor BxCxHxW C can be 1,3
+    return
+        im -> ndarray uint8 HxWxC 
+    '''
+    im_list = []
+    for i in range(tensor.shape[0]):
+        im = tensor.detach().cpu().data.numpy()[i]
+        im = im.transpose(1,2,0)
+        im = np.clip(im,min,max)
+        im = ((im-min)/(max-min)*255).astype(np.uint8)
+        im_list.append(im)
+    return im_list
+def cvimg2torch(img,min=0,max=1):
+    '''
+    input:
+        im -> ndarray uint8 HxWxC 
+    return
+        tensor -> torch.tensor BxCxHxW 
+    '''
+    img = img.astype(float) / 255.0
+    img = img.transpose(2, 0, 1) # NHWC -> NCHW
+    img = np.expand_dims(img, 0)
+    img = torch.from_numpy(img).float()
+    return img
+
+
+def setup_seed(seed):
+    # np.random.seed(seed)
+    # random.seed(seed)
+    # torch.manual_seed(seed) #cpu
+    # torch.cuda.manual_seed_all(seed)  #并行gpu
+    torch.backends.cudnn.deterministic = True  #cpu/gpu结果一致
+    # torch.backends.cudnn.benchmark = False   #训练集变化不大时使训练加速
+
+def SauvolaModBinarization(image,n1=51,n2=51,k1=0.3,k2=0.3,default=True):
+    '''
+	 Binarization using Sauvola's algorithm
+		@name : SauvolaModBinarization
+	 parameters
+		@param image (numpy array of shape (3/1) of type np.uint8): color or gray scale image
+	 optional parameters
+		@param n1 (int) : window size for running sauvola during the first pass
+		@param n2 (int): window size for running sauvola during the second pass
+		@param k1 (float): k value corresponding to sauvola during the first pass
+		@param k2 (float): k value corresponding to sauvola during the second pass
+		@param default (bool) : bollean variable to set the above parameter as default. 
+			@param default is set to True : thus default values of the above optional parameters (n1,n2,k1,k2) are set to
+				n1 = 5 % of min(image height, image width)
+				n2 = 10 % of min(image height, image width)
+				k1 = 0.5
+				k2 = 0.5
+		Returns
+			@return A binary image of same size as @param image
+		
+		@cite https://drive.google.com/file/d/1D3CyI5vtodPJeZaD2UV5wdcaIMtkBbdZ/view?usp=sharing
+    '''
+
+    if(default):
+        n1 = int(0.05*min(image.shape[0],image.shape[1]))
+        if (n1%2==0):
+            n1 = n1+1
+        n2 = int(0.1*min(image.shape[0],image.shape[1]))
+        if (n2%2==0):
+            n2 = n2+1
+        k1 = 0.5
+        k2 = 0.5
+    if(image.ndim==3):
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    else:
+        gray = np.copy(image)
+    T1 = threshold_sauvola(gray, window_size=n1,k=k1)
+    max_val = np.amax(gray)
+    min_val = np.amin(gray)
+    C = np.copy(T1)
+    C = C.astype(np.float32)
+    C[gray > T1] = (gray[gray > T1] - T1[gray > T1])/(max_val - T1[gray > T1])
+    C[gray <= T1] = 0
+    C = C * 255.0
+    new_in = np.copy(C.astype(np.uint8))
+    T2 = threshold_sauvola(new_in, window_size=n2,k=k2)
+    binary = np.copy(gray)
+    binary[new_in <= T2] = 0
+    binary[new_in > T2] = 255
+    return binary,T2
+
+
+def getBasecoord(h,w):
+    base_coord0 = np.tile(np.arange(h).reshape(h,1),(1,w)).astype(np.float32)
+    base_coord1 = np.tile(np.arange(w).reshape(1,w),(h,1)).astype(np.float32)
+    base_coord = np.concatenate((np.expand_dims(base_coord1,-1),np.expand_dims(base_coord0,-1)),-1)
+    return base_coord
+
+
+
+
+
+
+import numpy as np
+from scipy import ndimage as ndi
+
+# lookup tables for bwmorph_thin
+
+G123_LUT = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1,
+       0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0,
+       1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+       0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1,
+       0, 0, 0], dtype=np.bool)
+
+G123P_LUT = np.array([0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0,
+       1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0,
+       0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0,
+       1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1,
+       0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0], dtype=np.bool)
+
+def bwmorph(image, n_iter=None):
+    """
+    Perform morphological thinning of a binary image
+    
+    Parameters
+    ----------
+    image : binary (M, N) ndarray
+        The image to be thinned.
+    
+    n_iter : int, number of iterations, optional
+        Regardless of the value of this parameter, the thinned image
+        is returned immediately if an iteration produces no change.
+        If this parameter is specified it thus sets an upper bound on
+        the number of iterations performed.
+    
+    Returns
+    -------
+    out : ndarray of bools
+        Thinned image.
+    
+    See also
+    --------
+    skeletonize
+    
+    Notes
+    -----
+    This algorithm [1]_ works by making multiple passes over the image,
+    removing pixels matching a set of criteria designed to thin
+    connected regions while preserving eight-connected components and
+    2 x 2 squares [2]_. In each of the two sub-iterations the algorithm
+    correlates the intermediate skeleton image with a neighborhood mask,
+    then looks up each neighborhood in a lookup table indicating whether
+    the central pixel should be deleted in that sub-iteration.
+    
+    References
+    ----------
+    .. [1] Z. Guo and R. W. Hall, "Parallel thinning with
+           two-subiteration algorithms," Comm. ACM, vol. 32, no. 3,
+           pp. 359-373, 1989.
+    .. [2] Lam, L., Seong-Whan Lee, and Ching Y. Suen, "Thinning
+           Methodologies-A Comprehensive Survey," IEEE Transactions on
+           Pattern Analysis and Machine Intelligence, Vol 14, No. 9,
+           September 1992, p. 879
+    
+    Examples
+    --------
+    >>> square = np.zeros((7, 7), dtype=np.uint8)
+    >>> square[1:-1, 2:-2] = 1
+    >>> square[0,1] =  1
+    >>> square
+    array([[0, 1, 0, 0, 0, 0, 0],
+           [0, 0, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 0, 0],
+           [0, 0, 1, 1, 1, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
+    >>> skel = bwmorph_thin(square)
+    >>> skel.astype(np.uint8)
+    array([[0, 1, 0, 0, 0, 0, 0],
+           [0, 0, 1, 0, 0, 0, 0],
+           [0, 0, 0, 1, 0, 0, 0],
+           [0, 0, 0, 1, 0, 0, 0],
+           [0, 0, 0, 1, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
+    """
+    # check parameters
+    if n_iter is None:
+        n = -1
+    elif n_iter <= 0:
+        raise ValueError('n_iter must be > 0')
+    else:
+        n = n_iter
+    
+    # check that we have a 2d binary image, and convert it
+    # to uint8
+    skel = np.array(image).astype(np.uint8)
+    
+    if skel.ndim != 2:
+        raise ValueError('2D array required')
+    if not np.all(np.in1d(image.flat,(0,1))):
+        raise ValueError('Image contains values other than 0 and 1')
+
+    # neighborhood mask
+    mask = np.array([[ 8,  4,  2],
+                     [16,  0,  1],
+                     [32, 64,128]],dtype=np.uint8)
+
+    # iterate either 1) indefinitely or 2) up to iteration limit
+    while n != 0:
+        before = np.sum(skel) # count points before thinning
+        
+        # for each subiteration
+        for lut in [G123_LUT, G123P_LUT]:
+            # correlate image with neighborhood mask
+            N = ndi.correlate(skel, mask, mode='constant')
+            # take deletion decision from this subiteration's LUT
+            D = np.take(lut, N)
+            # perform deletion
+            skel[D] = 0
+            
+        after = np.sum(skel) # coint points after thinning
+        
+        if before == after:
+            # iteration had no effect: finish
+            break
+            
+        # count down to iteration limit (or endlessly negative)
+        n -= 1
+    
+    return skel.astype(np.bool)
+    
+"""
+# here's how to make the LUTs
+def nabe(n):
+    return np.array([n>>i&1 for i in range(0,9)]).astype(np.bool)
+def hood(n):
+    return np.take(nabe(n), np.array([[3, 2, 1],
+                                      [4, 8, 0],
+                                      [5, 6, 7]]))
+def G1(n):
+    s = 0
+    bits = nabe(n)
+    for i in (0,2,4,6):
+        if not(bits[i]) and (bits[i+1] or bits[(i+2) % 8]):
+            s += 1
+    return s==1
+            
+g1_lut = np.array([G1(n) for n in range(256)])
+def G2(n):
+    n1, n2 = 0, 0
+    bits = nabe(n)
+    for k in (1,3,5,7):
+        if bits[k] or bits[k-1]:
+            n1 += 1
+        if bits[k] or bits[(k+1) % 8]:
+            n2 += 1
+    return min(n1,n2) in [2,3]
+g2_lut = np.array([G2(n) for n in range(256)])
+g12_lut = g1_lut & g2_lut
+def G3(n):
+    bits = nabe(n)
+    return not((bits[1] or bits[2] or not(bits[7])) and bits[0])
+def G3p(n):
+    bits = nabe(n)
+    return not((bits[5] or bits[6] or not(bits[3])) and bits[4])
+g3_lut = np.array([G3(n) for n in range(256)])
+g3p_lut = np.array([G3p(n) for n in range(256)])
+g123_lut  = g12_lut & g3_lut
+g123p_lut = g12_lut & g3p_lut
+"""
+
+"""
+author : Peb Ruswono Aryan
+
+metric for evaluating binarization algorithms
+implemented : 
+
+ * F-Measure
+ * pseudo F-Measure (as in H-DIBCO 2010 & 2012)
+ * Peak Signal to Noise Ratio (PSNR)
+ * Negative Rate Measure (NRM)
+ * Misclassification Penaltiy Measure (MPM)
+ * Distance Reciprocal Distortion (DRD)
+
+usage:
+	python metric.py test-image.png ground-truth-image.png
+"""
+
+
+def drd_fn(im, im_gt):
+	height, width = im.shape
+	neg = np.zeros(im.shape)
+	neg[im_gt!=im] = 1
+	y, x = np.unravel_index(np.flatnonzero(neg), im.shape)
+	
+	n = 2
+	m = n*2+1
+	W = np.zeros((m,m), dtype=np.uint8)
+	W[n,n] = 1.
+	W = cv2.distanceTransform(1-W, cv2.DIST_L2, cv2.DIST_MASK_PRECISE)
+	W[n,n] = 1.
+	W = 1./W
+	W[n,n] = 0.
+	W /= W.sum()
+	
+	nubn = 0.
+	block_size = 8
+	for y1 in range(0, height, block_size):
+		for x1 in range(0, width, block_size):
+			y2 = min(y1+block_size-1,height-1)
+			x2 = min(x1+block_size-1,width-1)
+			block_dim = (x2-x1+1)*(y1-y1+1)
+			block = 1-im_gt[y1:y2, x1:x2]
+			block_sum = np.sum(block)
+			if block_sum>0 and block_sum<block_dim:
+				nubn += 1
+
+	drd_sum= 0.
+	tmp = np.zeros(W.shape)
+	for i in range(min(1,len(y))):
+		tmp[:,:] = 0 
+
+		x1 = max(0, x[i]-n)
+		y1 = max(0, y[i]-n)
+		x2 = min(width-1, x[i]+n)
+		y2 = min(height-1, y[i]+n)
+
+		yy1 = y1-y[i]+n
+		yy2 = y2-y[i]+n
+		xx1 = x1-x[i]+n
+		xx2 = x2-x[i]+n
+
+		tmp[yy1:yy2+1,xx1:xx2+1] = np.abs(im[y[i],x[i]]-im_gt[y1:y2+1,x1:x2+1])
+		tmp *= W
+
+		drd_sum += np.sum(tmp)
+	return drd_sum/nubn
+
+def bin_metric(im,im_gt):
+	height, width = im.shape
+	npixel = height*width
+
+	im[im>0] = 1
+	gt_mask = im_gt==0
+	im_gt[im_gt>0] = 1
+
+	sk = bwmorph(1-im_gt)
+	im_sk = np.ones(im_gt.shape)
+	im_sk[sk] = 0
+	
+	kernel = np.ones((3,3), dtype=np.uint8)
+	im_dil = cv2.erode(im_gt, kernel)
+	im_gtb = im_gt-im_dil
+	im_gtbd = cv2.distanceTransform(1-im_gtb, cv2.DIST_L2, 3)
+	
+	nd = im_gtbd.sum()
+
+	ptp = np.zeros(im_gt.shape)
+	ptp[(im==0) & (im_sk==0)] = 1
+	numptp = ptp.sum()
+
+	tp = np.zeros(im_gt.shape)
+	tp[(im==0) & (im_gt==0)] = 1
+	numtp = tp.sum()
+
+	tn = np.zeros(im_gt.shape)
+	tn[(im==1) & (im_gt==1)] = 1
+	numtn = tn.sum()
+
+	fp = np.zeros(im_gt.shape)
+	fp[(im==0) & (im_gt==1)] = 1
+	numfp = fp.sum()
+
+	fn = np.zeros(im_gt.shape)
+	fn[(im==1) & (im_gt==0)] = 1
+	numfn = fn.sum()
+
+	precision = numtp / (numtp + numfp)
+	recall = numtp / (numtp + numfn)
+	precall = numptp / np.sum(1-im_sk)
+	fmeasure = (2*recall*precision)/(recall+precision)
+	pfmeasure = (2*precall*precision)/(precall+precision)
+
+	mse = (numfp+numfn)/npixel
+	psnr = 10.*np.log10(1./mse)
+
+	nrfn = numfn / (numfn + numtp)
+	nrfp = numfp / (numfp + numtn)
+	nrm = (nrfn + nrfp)/2
+
+	im_dn = im_gtbd.copy()
+	im_dn[fn==0] = 0
+	dn = np.sum(im_dn)
+	mpfn = dn / nd
+
+	im_dp = im_gtbd.copy()
+	im_dp[fp==0] = 0
+	dp = np.sum(im_dp)
+	mpfp = dp / nd
+
+	mpm = (mpfp + mpfn) / 2
+	drd = drd_fn(im, im_gt)
+
+	return fmeasure, pfmeasure,psnr,nrm, mpm,drd
+	# print("F-measure\t: {0}\npF-measure\t: {1}\nPSNR\t\t: {2}\nNRM\t\t: {3}\nMPM\t\t: {4}\nDRD\t\t: {5}".format(fmeasure, pfmeasure, psnr, nrm, mpm, drd))

doctra/ui/app.py

@@ -2,6 +2,11 @@ import os
 import shutil
 import tempfile
 import re
+import traceback
+import pandas as pd
+import html as _html
+import base64
+import json
 from pathlib import Path
 from typing import Optional, Tuple, List, Dict, Any
 
@@ -9,6 +14,7 @@ import gradio as gr
 
 from doctra.parsers.structured_pdf_parser import StructuredPDFParser
 from doctra.parsers.table_chart_extractor import ChartTablePDFParser
+from doctra.utils.pdf_io import render_pdf_to_images
 
 
 def _gather_outputs(out_dir: Path, allowed_kinds: Optional[List[str]] = None, zip_filename: Optional[str] = None, is_structured_parsing: bool = False) -> Tuple[List[tuple[str, str]], List[str], str]:
@@ -100,7 +106,6 @@ def _parse_markdown_by_pages(md_content: str) -> List[Dict[str, Any]]:
     Parse markdown content and organize it by pages.
     Returns a list of page dictionaries with content, tables, charts, and figures.
     """
-    import re
     
     pages = []
     current_page = None
@@ -209,7 +214,6 @@ def run_full_parse(
     try:
         parser.parse(str(input_pdf))
     except Exception as e:
-        import traceback
         traceback.print_exc()
         # Safely encode error message for return value
         try:
@@ -325,8 +329,6 @@ def run_extract(
             if excel_filename:
                 excel_path = out_dir / excel_filename
                 if excel_path.exists():
-                    import pandas as pd
-                    import html as _html
                     
                     # Read Excel file and create HTML tables
                     xl_file = pd.ExcelFile(excel_path)
@@ -489,7 +491,6 @@ def build_demo() -> gr.Blocks:
 
             def parse_markdown_by_pages(md_content: str):
                 """Parse markdown content and organize it by pages."""
-                import re
                 
                 pages = []
                 current_page = None
@@ -548,7 +549,6 @@ def build_demo() -> gr.Blocks:
                     return "Page not found", None
                 
                 # Build HTML with inline base64 images, render markdown tables, and preserve paragraphs/line breaks
-                import html as _html, base64, re as _re
                 base_dir = None
                 try:
                     stem = Path(pdf_path).stem if pdf_path else ""
@@ -589,7 +589,7 @@ def build_demo() -> gr.Blocks:
                     stripped = line.strip()
                     if stripped.startswith('![') and ('](images/' in stripped or '](images\\' in stripped):
                         flush_paragraph()
-                        match = _re.match(r'!\[([^\]]+)\]\(([^)]+)\)', stripped)
+                        match = re.match(r'!\[([^\]]+)\]\(([^)]+)\)', stripped)
                         if match and base_dir is not None:
                             caption = match.group(1)
                             rel_path = match.group(2).replace('\\\\', '/').replace('\\', '/').lstrip('/')
@@ -646,7 +646,6 @@ def build_demo() -> gr.Blocks:
                 # Ensure page images are prepared
                 try:
                     if pdf_path and not page_images:
-                        from doctra.utils.pdf_io import render_pdf_to_images
                         tmp_img_dir = Path(tempfile.mkdtemp(prefix="doctra_pages_"))
                         pil_pages = render_pdf_to_images(pdf_path)
                         saved_paths: List[str] = []
@@ -726,7 +725,6 @@ def build_demo() -> gr.Blocks:
                     for page in pages_data:
                         for line in page['content']:
                             if line.strip().startswith('![') and ('](images/' in line or '](images\\' in line):
-                                import re
                                 match = re.match(r'!\[([^\]]+)\]\(([^)]+)\)', line.strip())
                                 if match:
                                     caption = match.group(1)
@@ -745,7 +743,6 @@ def build_demo() -> gr.Blocks:
                 saved_paths: List[str] = []
                 try:
                     if input_pdf_path:
-                        from doctra.utils.pdf_io import render_pdf_to_images
                         tmp_img_dir = Path(tempfile.mkdtemp(prefix="doctra_pages_"))
                         pil_pages = render_pdf_to_images(input_pdf_path)
                         for idx, (im, _, _) in enumerate(pil_pages, start=1):
@@ -759,7 +756,6 @@ def build_demo() -> gr.Blocks:
 
                 # Build initial HTML with inline images and proper blocks for first page
                 if pages_data:
-                    import html as _html, base64, re as _re
                     base_dir = None
                     try:
                         stem = Path(input_pdf_path).stem if input_pdf_path else ""
@@ -771,7 +767,7 @@ def build_demo() -> gr.Blocks:
                     for raw_line in pages_data[0]['content']:
                         line = raw_line.strip()
                         if line.startswith('![') and ('](images/' in line or '](images\\' in line):
-                            match = _re.match(r'!\[([^\]]+)\]\(([^)]+)\)', line)
+                            match = re.match(r'!\[([^\]]+)\]\(([^)]+)\)', line)
                             if match and base_dir is not None:
                                 caption = match.group(1)
                                 rel_path = match.group(2).replace('\\\\', '/').replace('\\', '/').lstrip('/')
@@ -874,7 +870,6 @@ def build_demo() -> gr.Blocks:
                     if not mapping.exists():
                         return gr.Dropdown(choices=[], value=None, visible=False)
                     
-                    import json
                     data = json.loads(mapping.read_text(encoding="utf-8"))
                     choices = []
                     
@@ -902,7 +897,6 @@ def build_demo() -> gr.Blocks:
                     if not mapping.exists():
                         return "", None
                     
-                    import json, html as _html
                     data = json.loads(mapping.read_text(encoding="utf-8"))
                     
                     for entry in data:

doctra/utils/structured_utils.py

@@ -14,7 +14,7 @@ def to_structured_dict(obj: Any) -> Optional[Dict[str, Any]]:
       - JSON string
       - dict
       - Pydantic BaseModel (v1 .dict() or v2 .model_dump())
-    Returns a normalized dict with keys: title, headers, rows — or None.
+    Returns a normalized dict with keys: title, description, headers, rows, page, type — or None.
     """
     if obj is None:
         return None
@@ -36,10 +36,13 @@ def to_structured_dict(obj: Any) -> Optional[Dict[str, Any]]:
 
     if isinstance(obj, dict):
         title = obj.get("title") or "Untitled"
+        description = obj.get("description") or ""
         headers = obj.get("headers") or []
         rows = obj.get("rows") or []
+        page = obj.get("page", "Unknown")
+        item_type = obj.get("type", "Table")
         if not isinstance(headers, list) or not isinstance(rows, list):
             return None
-        return {"title": title, "headers": headers, "rows": rows}
+        return {"title": title, "description": description, "headers": headers, "rows": rows, "page": page, "type": item_type}
 
     return None

doctra/version.py

@@ -1,2 +1,2 @@
 """Version information for Doctra."""
-__version__ = '0.3.3'
+__version__ = '0.4.1'

{doctra-0.3.3.dist-info → doctra-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: doctra
-Version: 0.3.3
+Version: 0.4.1
 Summary: Parse, extract, and analyze documents with ease
 Home-page: https://github.com/AdemBoukhris457/Doctra
 Author: Adem Boukhris

doctra-0.4.1.dist-info/RECORD

@@ -0,0 +1,67 @@
+doctra/__init__.py,sha256=rNLCyODOpaPb_TTP6qmQnuWZJW9JPXrxg1IfKnvb1No,773
+doctra/version.py,sha256=gJX4jQdS3czcKE2h1k17fJPgWzxHyGH2oFP9nW9cTLw,62
+doctra/cli/__init__.py,sha256=4PTujjYRShOOUlZ7PwuWckShPWLC4v4CYIhJpzgyv1k,911
+doctra/cli/main.py,sha256=_gvG8bm-Mn1tIEw6eJUgqz9dYEo9klXGiJDJzjqgPyo,43503
+doctra/cli/utils.py,sha256=w3Bxyzczcbl_cs1Cea8C3ehv7dkGl_wecprYZXrcGhk,11772
+doctra/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doctra/engines/image_restoration/__init__.py,sha256=vzcN6Rw7_U-5jIK2pdo2NlgqdLdXDShigrOGM7QLNEE,263
+doctra/engines/image_restoration/docres_engine.py,sha256=n9Pr0R7dbu_UHv51urGv_wC6ZYW-43bmXxiyTCOEOMo,21612
+doctra/engines/layout/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doctra/engines/layout/layout_models.py,sha256=vuTzjWd3FD-SkFPngktmUVhOJ6Xvff6ufwFEq796PQs,3162
+doctra/engines/layout/paddle_layout.py,sha256=P2-Gk8wHpWoA5Jpmo_3OLI59zWq3HeAOBOUKKVdXu8I,6792
+doctra/engines/ocr/__init__.py,sha256=h6bFiveGXdI59fsKzCqOXki3C74DCndEmvloOtMqnR0,133
+doctra/engines/ocr/api.py,sha256=YOBKDLExXpvSiOsc_TDJasaMPxzdVx1llQCtYlsruWo,1280
+doctra/engines/ocr/path_resolver.py,sha256=2_7Nsekt3dCDU3oVsgdr62iMrlAhbGNfYwgh4G7S3pA,1492
+doctra/engines/ocr/pytesseract_engine.py,sha256=Imz2uwju6himkBiS8CH7DLxBRe-LtmMYZiOdb_6PoQw,2911
+doctra/engines/vlm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doctra/engines/vlm/outlines_types.py,sha256=fQK6ru7XiXHaa8JPpaTTBaTk_zQ93ZyhFp4SyAnUdVU,1337
+doctra/engines/vlm/provider.py,sha256=aE8Eo1U-8XqAimakNlT0-T4etIyCV8rZ3DwxdqbFeTc,3131
+doctra/engines/vlm/service.py,sha256=nygxMe7uTq6Bv70ycBPL59F2a0ESp1Hix4j833p6rUM,4343
+doctra/exporters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doctra/exporters/excel_writer.py,sha256=rwyqlH73P7z413BELovQY_pS6IMkkqHEho6mbPrJ2Sk,11857
+doctra/exporters/html_writer.py,sha256=OlW24Eg5bZcjldRHtd3GDD7RrajuRXj43EJpXIJkYf8,38810
+doctra/exporters/image_saver.py,sha256=zsPoQ0CwoE643ui4iZMdXk96kv5mU8L_zC2JfF22N1A,1639
+doctra/exporters/markdown_table.py,sha256=4_OJIwG_WoIPYBzJx1njy_3tNVdkK6QKSP-P9r-b0zw,2030
+doctra/exporters/markdown_writer.py,sha256=L7EjF2MB8jYX7XkZ3a3NeeEC8gnb0qzRPTzIN9tdfuw,1027
+doctra/parsers/__init__.py,sha256=8M6LVzcWGpuTIK_1SMXML3ll7zK1CTHXGI5qXvqdm-A,206
+doctra/parsers/enhanced_pdf_parser.py,sha256=NBBopYdSIHWd_O96J0qR3DqZvbAt3CfK1hwUkXu8540,18377
+doctra/parsers/layout_order.py,sha256=W6b-T11H907RZ2FaZwNvnYhmvH11rpUzxC5yLkdf28k,640
+doctra/parsers/structured_pdf_parser.py,sha256=AU6yLW2kpd8bxZjelmm73L4CVBysnVAdKxwPkTV1Fzk,19602
+doctra/parsers/table_chart_extractor.py,sha256=ePmk9m9n-mvkqOvxpWC42ElxbnKMmDnq-e6SWiNqgzA,14195
+doctra/third_party/docres/inference.py,sha256=krD5EQDiqki-5uTMqqHYivhL38sfSOhYgaihI751070,13576
+doctra/third_party/docres/utils.py,sha256=N0ZVmOTB3wsinFlYu5hT84C4_MhWGdc98T8LTG-S9dA,14566
+doctra/third_party/docres/data/MBD/MBD.py,sha256=-d6cVQX1FVcGmQ_yJ5l-PQ3xKmkmveQQBytZ38pEGfY,4653
+doctra/third_party/docres/data/MBD/MBD_utils.py,sha256=z8La4F-yglk6fh8KraBUom8QXJLseYden7OBmFtoO7g,11783
+doctra/third_party/docres/data/MBD/infer.py,sha256=xm9ZCnLJLV5TxJjAH-ith7pSFI18J_8CEUpcYCFDLu8,6205
+doctra/third_party/docres/data/MBD/model/deep_lab_model/aspp.py,sha256=IdVcmhl88N6vFe2bnr-G4CEtbUxLSfhKa9T-Wy60otM,3708
+doctra/third_party/docres/data/MBD/model/deep_lab_model/decoder.py,sha256=5eQ9FT-J1Bd-CmA2dYXvVo_PjrpEy-RmSjESLpNReBA,2435
+doctra/third_party/docres/data/MBD/model/deep_lab_model/deeplab.py,sha256=u8pNRvuBzZoDhlr8IsxPzjN2-sMBN3ZnyBFydS9aGj8,3111
+doctra/third_party/docres/data/MBD/model/deep_lab_model/backbone/__init__.py,sha256=TsynqBTJgmodrSTDqlKlbYdnYkJJd19lsDrpR-3XMno,539
+doctra/third_party/docres/data/MBD/model/deep_lab_model/backbone/drn.py,sha256=M3kHjU4stdY7B-urpkmEmw-aTJ1dleOGXNOqGv2JrxU,15034
+doctra/third_party/docres/data/MBD/model/deep_lab_model/backbone/mobilenet.py,sha256=yBqu1LLs7M_5NIztnC8alB42E2xT59pvziIFhYNrMkY,5553
+doctra/third_party/docres/data/MBD/model/deep_lab_model/backbone/resnet.py,sha256=W53_VRAlrkY743s_Kpt9MLP3cFVJ0zYVW2J7EBhUQW4,6704
+doctra/third_party/docres/data/MBD/model/deep_lab_model/backbone/xception.py,sha256=HupHNVeeWNsiX8tWy8lQ0ZPUtrf_AaO7rwf_1xV_k0I,11854
+doctra/third_party/docres/data/MBD/model/deep_lab_model/sync_batchnorm/__init__.py,sha256=LHo9Qoia89mwgGImciJALSiMjdzpFHWLwXEi52S6aRg,458
+doctra/third_party/docres/data/MBD/model/deep_lab_model/sync_batchnorm/batchnorm.py,sha256=62Ku4DciMwETTxyjFFPxDB8-UJl53Vi3MCtb82lbfkA,13213
+doctra/third_party/docres/data/MBD/model/deep_lab_model/sync_batchnorm/comm.py,sha256=bGjH2iEqQXOfXmuzm3zzGuB1Ocui6N79Nd8rVGgLqag,4569
+doctra/third_party/docres/data/MBD/model/deep_lab_model/sync_batchnorm/replicate.py,sha256=idizPejwQvHo6W38VoBMcBF3kb7_zlrRvPBqg2Pi-Ko,3305
+doctra/third_party/docres/data/MBD/model/deep_lab_model/sync_batchnorm/unittest.py,sha256=Ub3j1dz25V09d6wL5lpwR4NNQ4cktOe4mzzpOP-jLd4,863
+doctra/third_party/docres/data/preprocess/crop_merge_image.py,sha256=f2NANY92s6IQ1hl1MAXfftFPIyIrj24O4TONjg7SXEc,4747
+doctra/third_party/docres/models/restormer_arch.py,sha256=BSwv_odCcp4HUZj3gv21e4IzFRBiyk8FjKAO8kF4YS8,12510
+doctra/ui/__init__.py,sha256=XzOOKeGSBnUREuDQiCIWds1asFSa2nypFQTJXwclROA,85
+doctra/ui/app.py,sha256=iFSAVZacL7iHB1SHhcUzperJGNQVWqUhvOYdlgjjt50,43623
+doctra/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doctra/utils/bbox.py,sha256=R2-95p0KiWvet3TH27TQVvCar7WJg6z0u3L21iEDF-A,674
+doctra/utils/constants.py,sha256=ZWOvNDrvETbQ_pxHiX7vUW4J5Oj8_qnov0QacUOBizI,189
+doctra/utils/file_ops.py,sha256=3IS0EQncs6Kaj27fcg2zxQX3xRSvtItIsyKGLYgeOgw,815
+doctra/utils/io_utils.py,sha256=L1bWV4-ybs2j_3ZEN7GfQVgdC73JKVECVnpwKbP0dy0,219
+doctra/utils/ocr_utils.py,sha256=Doa1uYBg3kRgRYd2aPq9fICHgHfrM_efdhZfI7jl6OM,780
+doctra/utils/pdf_io.py,sha256=c8EY47Z1iqVtlLFHS_n0qGuXJ5ERFaMUd84ivXV0b9E,706
+doctra/utils/progress.py,sha256=IKQ_YErWSEd4hddYMUiCORy0_kW4TOYJM891HUEq2_E,11901
+doctra/utils/quiet.py,sha256=5XPS-1CtJ0sVk6qgSQctdhr_wR8mP1xoJLoUbmkXROA,387
+doctra/utils/structured_utils.py,sha256=vU84dsD8wIlTyMsA9hitorGH-eroQiVuWEpBTQBUT24,1478
+doctra-0.4.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+doctra-0.4.1.dist-info/METADATA,sha256=wXduiq7VJS5vf-TXdxpYFCKGfPyGYr5jGK0mwH3OjUw,28298
+doctra-0.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+doctra-0.4.1.dist-info/top_level.txt,sha256=jI7E8jHci2gP9y0GYaWxlg9jG0O5n3FjHJJPLXDXMds,7
+doctra-0.4.1.dist-info/RECORD,,