csf-scraper-python 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

csf_scraper/__init__.py

@@ -57,6 +57,7 @@ from csf_scraper.scraper import Scraper
 from csf_scraper.value_objects import CsfImage, IdCif, Rfc
 
 if TYPE_CHECKING:
+    from csf_scraper.image_readers.adapters.cpu import OpenCvImageReader
     from csf_scraper.image_readers.adapters.llms import GeminiImageReader
 
 __all__ = [
@@ -88,6 +89,7 @@ __all__ = [
     "InvalidImageFormatException",
     "InvalidRfcFormatException",
     "LlmImageReaderService",
+    "OpenCvImageReader",
     "PdfCsfTextParser",
     "PdfTextProvider",
     "PdfToTextConvertException",
@@ -115,5 +117,10 @@ def __getattr__(name: str) -> object:
         from csf_scraper.image_readers.adapters.llms import GeminiImageReader
 
         return GeminiImageReader
+    
+    if name == "OpenCvImageReader":
+        from csf_scraper.image_readers.adapters.cpu import OpenCvImageReader
+
+        return OpenCvImageReader
 
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

csf_scraper/image_readers/adapters/cpu/__init__.py

@@ -0,0 +1,18 @@
+"""Adaptadores de los lectores de imagen."""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from csf_scraper.image_readers.adapters.cpu.open_cv_image_reader import OpenCvImageReader
+
+__all__ = ["OpenCvImageReader"]
+
+
+def __getattr__(name: str) -> object:
+    """Reexporta los adaptadores concretos de forma perezosa."""
+    if name == "OpenCvImageReader":
+        from csf_scraper.image_readers.adapters.cpu.open_cv_image_reader import OpenCvImageReader
+
+        return OpenCvImageReader
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

csf_scraper/image_readers/adapters/cpu/open_cv/__init__.py

@@ -0,0 +1,37 @@
+from .config import DetectionConfig, EnhancementConfig, ScanConfig
+from .detection import DetectionResult, detect_document
+from .enhance import enhance_for_ocr, to_gray
+from .errors import (
+    DocumentNotFoundError,
+    DocumentScannerError,
+    ImageLoadError,
+    ImageSaveError,
+    InvalidGeometryError,
+)
+from .io import load_image, save_image
+from .pipeline import ScanResult, scan_array
+from .transform import four_point_transform, order_points, scale_points
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "DetectionConfig",
+    "DetectionResult",
+    "DocumentNotFoundError",
+    "DocumentScannerError",
+    "EnhancementConfig",
+    "ImageLoadError",
+    "ImageSaveError",
+    "InvalidGeometryError",
+    "ScanConfig",
+    "ScanResult",
+    "detect_document",
+    "enhance_for_ocr",
+    "four_point_transform",
+    "load_image",
+    "order_points",
+    "save_image",
+    "scale_points",
+    "scan_array",
+    "to_gray",
+]

csf_scraper/image_readers/adapters/cpu/open_cv/config.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+OutputMode = Literal["color", "gray", "bw"]
+ThresholdMethod = Literal["adaptive", "otsu"]
+
+
+def _require_odd_min(value: int, name: str, minimum: int = 3) -> None:
+    if value < minimum or value % 2 == 0:
+        raise ValueError(f"{name} must be an odd integer >= {minimum}, got {value}")
+
+
+@dataclass(frozen=True, slots=True)
+class DetectionConfig:
+    resize_height: int = 700
+    blur_ksize: int = 5
+    canny_low: int = 75
+    canny_high: int = 200
+    dilate_kernel: int = 9
+    dilate_iterations: int = 2
+    min_area_ratio: float = 0.05
+    max_area_ratio: float = 0.98
+    bright_open_kernel: int = 5
+    approx_epsilon_ratios: tuple[float, ...] = (0.02, 0.05, 0.08)
+    use_clahe: bool = True
+    clahe_clip_limit: float = 2.0
+    clahe_tile_grid: tuple[int, int] = (8, 8)
+    min_confidence: float = 0.08
+
+    def __post_init__(self) -> None:
+        if self.resize_height < 100:
+            raise ValueError("resize_height must be >= 100")
+        _require_odd_min(self.blur_ksize, "blur_ksize")
+        _require_odd_min(self.dilate_kernel, "dilate_kernel")
+        _require_odd_min(self.bright_open_kernel, "bright_open_kernel")
+        if self.canny_low >= self.canny_high:
+            raise ValueError("canny_low must be lower than canny_high")
+        if not 0 < self.min_area_ratio < self.max_area_ratio <= 1:
+            raise ValueError("area ratios must satisfy 0 < min < max <= 1")
+        if self.dilate_iterations < 1:
+            raise ValueError("dilate_iterations must be >= 1")
+        if not self.approx_epsilon_ratios:
+            raise ValueError("approx_epsilon_ratios cannot be empty")
+        if any(ratio <= 0 for ratio in self.approx_epsilon_ratios):
+            raise ValueError("approx_epsilon_ratios must contain positive values")
+        if not 0 <= self.min_confidence <= 1:
+            raise ValueError("min_confidence must be between 0 and 1")
+
+
+@dataclass(frozen=True, slots=True)
+class EnhancementConfig:
+    mode: OutputMode = "bw"
+    use_clahe: bool = True
+    clahe_clip_limit: float = 2.0
+    clahe_tile_grid: tuple[int, int] = (8, 8)
+    threshold_method: ThresholdMethod = "adaptive"
+    adaptive_block_size: int = 31
+    adaptive_c: float = 10.0
+    denoise: bool = True
+    min_ocr_width: int = 1000
+    max_upscale: float = 3.0
+
+    def __post_init__(self) -> None:
+        if self.mode not in ("color", "gray", "bw"):
+            raise ValueError("mode must be one of: color, gray, bw")
+        if self.threshold_method not in ("adaptive", "otsu"):
+            raise ValueError("threshold_method must be adaptive or otsu")
+        _require_odd_min(self.adaptive_block_size, "adaptive_block_size")
+        if self.adaptive_c < 0:
+            raise ValueError("adaptive_c must be >= 0")
+        if self.min_ocr_width < 0:
+            raise ValueError("min_ocr_width must be >= 0")
+        if self.max_upscale < 1:
+            raise ValueError("max_upscale must be >= 1")
+
+
+@dataclass(frozen=True, slots=True)
+class ScanConfig:
+    detection: DetectionConfig = field(default_factory=DetectionConfig)
+    enhancement: EnhancementConfig = field(default_factory=EnhancementConfig)
+    allow_full_image_fallback: bool = True
+    debug: bool = False

csf_scraper/image_readers/adapters/cpu/open_cv/detection.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+from collections.abc import Iterator, Sequence
+from dataclasses import dataclass, field
+
+import cv2
+import numpy as np
+
+from .config import DetectionConfig
+from .enhance import apply_clahe, to_gray
+from .errors import InvalidGeometryError
+from .transform import order_points
+
+
+@dataclass(slots=True)
+class DetectionResult:
+    quad: np.ndarray | None
+    confidence: float
+    method: str
+    scale: float
+    debug: dict[str, np.ndarray] = field(default_factory=dict)
+    variant: str = ""
+
+    @property
+    def found(self) -> bool:
+        return self.quad is not None
+
+
+def _prepare_work_image(gray: np.ndarray, config: DetectionConfig) -> tuple[np.ndarray, float]:
+    height, width = gray.shape[:2]
+    scale = min(1.0, config.resize_height / float(height))
+    if scale < 1.0:
+        size = (max(1, round(width * scale)), max(1, round(height * scale)))
+        work = cv2.resize(gray, size, interpolation=cv2.INTER_AREA)
+    else:
+        work = gray.copy()
+
+    if config.use_clahe:
+        work = apply_clahe(work, config.clahe_clip_limit, config.clahe_tile_grid)
+
+    return work, scale
+
+
+def _edge_masks(
+    work: np.ndarray,
+    config: DetectionConfig,
+) -> tuple[np.ndarray, np.ndarray, list[tuple[str, np.ndarray]]]:
+    blurred = cv2.GaussianBlur(
+        work,
+        (config.blur_ksize, config.blur_ksize),
+        0,
+    )
+    edges = cv2.Canny(blurred, config.canny_low, config.canny_high)
+
+    small_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
+    kernel = cv2.getStructuringElement(
+        cv2.MORPH_RECT,
+        (config.dilate_kernel, config.dilate_kernel),
+    )
+    small_dilated = cv2.dilate(edges, small_kernel, iterations=1)
+    dilated = cv2.dilate(edges, kernel, iterations=config.dilate_iterations)
+    closed = cv2.morphologyEx(dilated, cv2.MORPH_CLOSE, kernel)
+
+    bright_kernel = cv2.getStructuringElement(
+        cv2.MORPH_RECT,
+        (config.bright_open_kernel, config.bright_open_kernel),
+    )
+    _, bright = cv2.threshold(
+        work,
+        0,
+        255,
+        cv2.THRESH_BINARY | cv2.THRESH_OTSU,
+    )
+    bright = cv2.morphologyEx(bright, cv2.MORPH_OPEN, bright_kernel)
+    bright_ratio = cv2.countNonZero(bright) / float(bright.size)
+
+    masks = [
+        ("raw", edges),
+        ("dilate_small", small_dilated),
+        ("dilate_close", closed),
+    ]
+    if 0.02 < bright_ratio < 0.98:
+        masks.append(("bright", bright))
+    return edges, closed, masks
+
+
+def _approx_quad(contour: np.ndarray, epsilon_ratios: tuple[float, ...]) -> np.ndarray | None:
+    hull = cv2.convexHull(contour)
+    perimeter = cv2.arcLength(hull, True)
+    if perimeter <= 0:
+        return None
+    for ratio in epsilon_ratios:
+        approx = cv2.approxPolyDP(hull, ratio * perimeter, True)
+        if len(approx) == 4:
+            return approx.reshape(4, 2).astype(np.float32)
+    return None
+
+
+def _iter_candidates(
+    contours: Sequence[np.ndarray],
+    image_area: float,
+    config: DetectionConfig,
+) -> Iterator[tuple[np.ndarray, str, float]]:
+    valid: list[np.ndarray] = []
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area <= 0:
+            continue
+        ratio = area / image_area
+        if config.min_area_ratio <= ratio <= config.max_area_ratio:
+            valid.append(contour)
+
+    if not valid:
+        valid = sorted(contours, key=cv2.contourArea, reverse=True)[:5]
+
+    for contour in valid:
+        area = cv2.contourArea(contour)
+        hull = cv2.convexHull(contour)
+        hull_area = cv2.contourArea(hull)
+        solidity = area / hull_area if hull_area > 0 else 0.0
+
+        approx = _approx_quad(hull, config.approx_epsilon_ratios)
+        if approx is not None:
+            yield approx, "approx", solidity
+
+        rect = cv2.minAreaRect(contour)
+        box = cv2.boxPoints(rect).astype(np.float32)
+        yield box, "min_area_rect", solidity
+
+    if valid:
+        merged = np.vstack([contour.reshape(-1, 2) for contour in valid]).astype(np.float32)
+        merged_hull = cv2.convexHull(merged.reshape(-1, 1, 2))
+
+        approx = _approx_quad(merged_hull, config.approx_epsilon_ratios)
+        if approx is not None:
+            yield approx, "merged_hull", 1.0
+
+        box = cv2.boxPoints(cv2.minAreaRect(merged_hull)).astype(np.float32)
+        yield box, "merged_hull_rect", 1.0
+
+
+def _score_candidate(
+    quad: np.ndarray,
+    image_shape: tuple[int, int],
+    solidity: float,
+    method: str,
+) -> tuple[float, np.ndarray | None]:
+    try:
+        ordered = order_points(quad)
+    except InvalidGeometryError:
+        return -1.0, None
+
+    image_height, image_width = image_shape
+    image_area = float(image_height * image_width)
+    area = abs(cv2.contourArea(ordered))
+    if area <= 0:
+        return -1.0, None
+
+    area_ratio = area / image_area
+    if area_ratio < 0.02 or area_ratio > 1.0:
+        return -1.0, None
+
+    rect = cv2.minAreaRect(ordered.astype(np.float32))
+    rect_width, rect_height = rect[1]
+    rect_area = max(float(rect_width) * float(rect_height), 1e-6)
+    rectangularity = min(1.0, area / rect_area)
+
+    long_side = max(rect_width, rect_height)
+    short_side = max(min(rect_width, rect_height), 1e-6)
+    aspect = long_side / short_side
+
+    score = area_ratio * (0.5 + 0.5 * rectangularity)
+    score *= 0.7 + 0.3 * max(0.0, min(1.0, solidity))
+
+    if aspect < 0.25 or aspect > 4.0:
+        score *= 0.5
+    if area_ratio > 0.97:
+        score *= 0.2
+    elif area_ratio > 0.90:
+        score *= 0.5
+
+    margin_x = 0.015 * image_width
+    margin_y = 0.015 * image_height
+    border_contacts = int(
+        np.count_nonzero(
+            (ordered[:, 0] < margin_x)
+            | (ordered[:, 0] > image_width - 1 - margin_x)
+            | (ordered[:, 1] < margin_y)
+            | (ordered[:, 1] > image_height - 1 - margin_y)
+        )
+    )
+    if border_contacts:
+        score *= 0.55**border_contacts
+
+    score *= {
+        "approx": 1.0,
+        "merged_hull": 1.0,
+        "min_area_rect": 0.6,
+        "merged_hull_rect": 0.6,
+    }.get(method, 0.8)
+
+    return float(min(score, 1.0)), ordered
+
+
+def detect_document(
+    image: np.ndarray,
+    config: DetectionConfig | None = None,
+) -> DetectionResult:
+    cfg = config or DetectionConfig()
+    if image is None or image.size == 0:
+        raise ValueError("image cannot be empty")
+
+    gray = to_gray(image)
+    height, width = gray.shape[:2]
+    work, scale = _prepare_work_image(gray, cfg)
+    edges, closed, masks = _edge_masks(work, cfg)
+
+    image_area = float(work.shape[0] * work.shape[1])
+    image_shape = (work.shape[0], work.shape[1])
+    best_score = -1.0
+    best_quad: np.ndarray | None = None
+    best_method = "none"
+    best_variant = ""
+
+    for variant, mask in masks:
+        found_contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        contours = [np.asarray(contour) for contour in found_contours]
+        if not contours:
+            continue
+        for quad, method, solidity in _iter_candidates(contours, image_area, cfg):
+            score, ordered = _score_candidate(quad, image_shape, solidity, method)
+            if ordered is not None and score > best_score:
+                best_score = score
+                best_quad = ordered
+                best_method = method
+                best_variant = variant
+
+    debug = {
+        "gray": gray,
+        "work": work,
+        "edges": edges,
+        "closed": closed,
+    }
+
+    if best_quad is None:
+        return DetectionResult(None, 0.0, "none", scale, debug, "")
+
+    if best_score < cfg.min_confidence:
+        return DetectionResult(
+            None,
+            max(best_score, 0.0),
+            best_method,
+            scale,
+            debug,
+            best_variant,
+        )
+
+    quad_original = best_quad / scale
+    quad_original[:, 0] = np.clip(quad_original[:, 0], 0, width - 1)
+    quad_original[:, 1] = np.clip(quad_original[:, 1], 0, height - 1)
+
+    return DetectionResult(
+        quad_original.astype(np.float32),
+        best_score,
+        best_method,
+        scale,
+        debug,
+        best_variant,
+    )

csf_scraper/image_readers/adapters/cpu/open_cv/enhance.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import cv2
+import numpy as np
+
+from .config import EnhancementConfig
+
+
+def to_gray(image: np.ndarray) -> np.ndarray:
+    if image is None or image.size == 0:
+        raise ValueError("image cannot be empty")
+    if image.ndim == 2:
+        return image
+    channels = image.shape[2]
+    if channels == 3:
+        return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    if channels == 4:
+        return cv2.cvtColor(image, cv2.COLOR_BGRA2GRAY)
+    raise ValueError(f"unsupported channel count: {channels}")
+
+
+def apply_clahe(gray: np.ndarray, clip_limit: float, tile_grid: tuple[int, int]) -> np.ndarray:
+    clahe = cv2.createCLAHE(clipLimit=float(clip_limit), tileGridSize=tuple(tile_grid))
+    return clahe.apply(gray)
+
+
+def _upscale_if_needed(image: np.ndarray, min_width: int, max_upscale: float) -> np.ndarray:
+    if min_width <= 0:
+        return image
+    width = image.shape[1]
+    if width >= min_width:
+        return image
+    scale = min(min_width / float(width), max_upscale)
+    if scale <= 1.0:
+        return image
+    size = (round(image.shape[1] * scale), round(image.shape[0] * scale))
+    return cv2.resize(image, size, interpolation=cv2.INTER_CUBIC)
+
+
+def _enhance_color(image: np.ndarray, config: EnhancementConfig) -> np.ndarray:
+    enhanced = _upscale_if_needed(image, config.min_ocr_width, config.max_upscale)
+    if not config.use_clahe:
+        return enhanced
+    lab = cv2.cvtColor(enhanced, cv2.COLOR_BGR2LAB)
+    lightness, a_channel, b_channel = cv2.split(lab)
+    lightness = apply_clahe(lightness, config.clahe_clip_limit, config.clahe_tile_grid)
+    merged = cv2.merge([lightness, a_channel, b_channel])
+    return cv2.cvtColor(merged, cv2.COLOR_LAB2BGR)
+
+
+def _adaptive_block_size(requested: int, height: int, width: int) -> int | None:
+    limit = min(height, width)
+    if limit < 3:
+        return None
+    max_odd = limit if limit % 2 == 1 else limit - 1
+    return max(3, min(requested, max_odd))
+
+
+def _binarize(gray: np.ndarray, config: EnhancementConfig) -> np.ndarray:
+    if config.threshold_method == "otsu":
+        _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
+        return binary
+
+    block_size = _adaptive_block_size(
+        config.adaptive_block_size,
+        gray.shape[0],
+        gray.shape[1],
+    )
+    if block_size is None:
+        _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
+        return binary
+
+    return cv2.adaptiveThreshold(
+        gray,
+        255,
+        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+        cv2.THRESH_BINARY,
+        block_size,
+        float(config.adaptive_c),
+    )
+
+
+def enhance_for_ocr(image: np.ndarray, config: EnhancementConfig | None = None) -> np.ndarray:
+    cfg = config or EnhancementConfig()
+    if image is None or image.size == 0:
+        raise ValueError("image cannot be empty")
+
+    if cfg.mode == "color":
+        return _enhance_color(image, cfg)
+
+    gray = to_gray(image)
+    gray = _upscale_if_needed(gray, cfg.min_ocr_width, cfg.max_upscale)
+
+    if cfg.use_clahe:
+        gray = apply_clahe(gray, cfg.clahe_clip_limit, cfg.clahe_tile_grid)
+
+    if cfg.denoise:
+        gray = cv2.medianBlur(gray, 3)
+
+    if cfg.mode == "gray":
+        return gray
+
+    return _binarize(gray, cfg)

csf_scraper/image_readers/adapters/cpu/open_cv/errors.py

@@ -0,0 +1,18 @@
+class DocumentScannerError(Exception):
+    pass
+
+
+class ImageLoadError(DocumentScannerError):
+    pass
+
+
+class ImageSaveError(DocumentScannerError):
+    pass
+
+
+class DocumentNotFoundError(DocumentScannerError):
+    pass
+
+
+class InvalidGeometryError(DocumentScannerError):
+    pass

csf_scraper/image_readers/adapters/cpu/open_cv/io.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+from .errors import ImageLoadError, ImageSaveError
+
+
+def load_image(path: str | Path) -> np.ndarray:
+    source = Path(path)
+    if not source.is_file():
+        raise ImageLoadError(f"image not found: {source}")
+
+    image = cv2.imread(str(source), cv2.IMREAD_COLOR)
+    if image is None:
+        raise ImageLoadError(f"could not decode image: {source}")
+    return image
+
+
+def save_image(path: str | Path, image: np.ndarray) -> Path:
+    destination = Path(path)
+    if image is None or image.size == 0:
+        raise ImageSaveError("refusing to save an empty image")
+
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    success = cv2.imwrite(str(destination), image)
+    if not success:
+        raise ImageSaveError(f"could not write image: {destination}")
+    return destination

csf_scraper/image_readers/adapters/cpu/open_cv/pipeline.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import numpy as np
+
+from .config import ScanConfig
+from .detection import DetectionResult, detect_document
+from .enhance import enhance_for_ocr
+from .errors import DocumentNotFoundError, InvalidGeometryError
+from .qr import decode_qr
+from .transform import four_point_transform
+
+
+@dataclass(slots=True)
+class ScanResult:
+    image: np.ndarray
+    warped: np.ndarray
+    source: np.ndarray
+    detection: DetectionResult
+    method: str
+    confidence: float
+    config: ScanConfig = field(repr=False)
+    qr_code: str | None = None
+
+
+def _full_image_quad(image: np.ndarray) -> np.ndarray:
+    height, width = image.shape[:2]
+    return np.array(
+        [
+            [0, 0],
+            [width - 1, 0],
+            [width - 1, height - 1],
+            [0, height - 1],
+        ],
+        dtype=np.float32,
+    )
+
+
+def _full_image_fallback(
+    image: np.ndarray,
+    config: ScanConfig,
+) -> tuple[np.ndarray, np.ndarray, str, float]:
+    if not config.allow_full_image_fallback:
+        raise DocumentNotFoundError("document boundary not found")
+    return image.copy(), _full_image_quad(image), "full_image_fallback", 0.0
+
+
+def scan_array(image: np.ndarray, config: ScanConfig | None = None) -> ScanResult:
+    cfg = config or ScanConfig()
+    if image is None or image.size == 0:
+        raise ValueError("image cannot be empty")
+
+    detection = detect_document(image, cfg.detection)
+    detected_quad = detection.quad
+
+    if detected_quad is not None:
+        try:
+            warped, _ = four_point_transform(image, detected_quad)
+            quad = detected_quad
+            method = detection.method
+            confidence = detection.confidence
+        except InvalidGeometryError:
+            if not cfg.allow_full_image_fallback:
+                raise
+            warped, quad, method, confidence = _full_image_fallback(image, cfg)
+    else:
+        warped, quad, method, confidence = _full_image_fallback(image, cfg)
+
+    qr_code = decode_qr(warped, image)
+    enhanced = enhance_for_ocr(warped, cfg.enhancement)
+    detection_out = DetectionResult(
+        quad=quad,
+        confidence=confidence,
+        method=method,
+        scale=detection.scale,
+        debug=detection.debug,
+        variant=detection.variant,
+    )
+    return ScanResult(
+        image=enhanced,
+        warped=warped,
+        source=image,
+        detection=detection_out,
+        method=method,
+        confidence=confidence,
+        config=cfg,
+        qr_code=qr_code,
+    )

csf_scraper/image_readers/adapters/cpu/open_cv/qr.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from urllib.parse import urlparse
+
+import cv2
+import numpy as np
+
+SAT_QR_HOST = "siat.sat.gob.mx"
+QR_MIN_SIDE = 1000
+QR_MAX_SIDE = 2200
+
+
+def _is_sat_qr(code: str) -> bool:
+    host = (urlparse(code).hostname or "").lower()
+    return host == SAT_QR_HOST or host.endswith("." + SAT_QR_HOST)
+
+
+def _resize_for_qr(image: np.ndarray) -> np.ndarray:
+    height, width = image.shape[:2]
+    max_side = max(height, width)
+    if max_side <= 0:
+        return image
+    if max_side > QR_MAX_SIDE:
+        scale = QR_MAX_SIDE / float(max_side)
+    elif max_side < QR_MIN_SIDE:
+        scale = QR_MIN_SIDE / float(max_side)
+    else:
+        return image
+    size = (max(1, round(width * scale)), max(1, round(height * scale)))
+    interpolation = cv2.INTER_AREA if scale < 1.0 else cv2.INTER_CUBIC
+    return cv2.resize(image, size, interpolation=interpolation)
+
+
+def _to_gray(image: np.ndarray) -> np.ndarray | None:
+    if image.ndim == 2:
+        return image
+    if image.shape[2] == 3:
+        return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    if image.shape[2] == 4:
+        return cv2.cvtColor(image, cv2.COLOR_BGRA2GRAY)
+    return None
+
+
+def _candidate_images(image: np.ndarray) -> Iterator[np.ndarray]:
+    if image is None or image.size == 0:
+        return
+    resized = _resize_for_qr(image)
+    yield resized
+    gray = _to_gray(resized)
+    if gray is not None and gray is not resized:
+        yield gray
+
+
+def _decode_candidate(detector: cv2.QRCodeDetector, image: np.ndarray) -> str | None:
+    try:
+        text, points, _ = detector.detectAndDecode(image)
+    except cv2.error:
+        return None
+
+    text = text.strip() if text else ""
+    if text:
+        return text
+    if points is None:
+        return None
+
+    try:
+        x, y, width, height = cv2.boundingRect(points.reshape(-1, 2).astype(np.float32))
+    except cv2.error:
+        return None
+    if width <= 0 or height <= 0:
+        return None
+
+    pad_x = max(1, int(width * 0.2))
+    pad_y = max(1, int(height * 0.2))
+    x0 = max(0, x - pad_x)
+    y0 = max(0, y - pad_y)
+    x1 = min(image.shape[1], x + width + pad_x)
+    y1 = min(image.shape[0], y + height + pad_y)
+    crop = image[y0:y1, x0:x1]
+    if crop.size == 0:
+        return None
+
+    crop = cv2.resize(crop, None, fx=2.0, fy=2.0, interpolation=cv2.INTER_CUBIC)
+    try:
+        text, _, _ = detector.detectAndDecode(crop)
+    except cv2.error:
+        return None
+    return text.strip() if text else None
+
+
+def decode_qr(*images: np.ndarray) -> str | None:
+    detector = cv2.QRCodeDetector()
+    fallback: str | None = None
+
+    for image in images:
+        if image is None or image.size == 0:
+            continue
+        for candidate in _candidate_images(image):
+            code = _decode_candidate(detector, candidate)
+            if not code:
+                continue
+            if _is_sat_qr(code):
+                return code
+            if fallback is None:
+                fallback = code
+
+    return fallback

csf_scraper/image_readers/adapters/cpu/open_cv/transform.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import cv2
+import numpy as np
+
+from .errors import InvalidGeometryError
+
+PointSet = np.ndarray | Sequence[Sequence[float]]
+
+
+def _validate_points(pts: PointSet) -> np.ndarray:
+    points = np.asarray(pts, dtype=np.float32).reshape(-1, 2)
+    if points.shape != (4, 2):
+        raise InvalidGeometryError(f"expected 4 points, got shape {points.shape}")
+    if not np.isfinite(points).all():
+        raise InvalidGeometryError("points contain non-finite values")
+    if len(np.unique(points, axis=0)) != 4:
+        raise InvalidGeometryError("points must be distinct")
+    return points
+
+
+def _signed_area(points: np.ndarray) -> float:
+    x = points[:, 0]
+    y = points[:, 1]
+    return float(0.5 * np.sum(x * np.roll(y, -1) - np.roll(x, -1) * y))
+
+
+def order_points(pts: PointSet) -> np.ndarray:
+    points = _validate_points(pts)
+    center = points.mean(axis=0)
+    angles = np.arctan2(points[:, 1] - center[1], points[:, 0] - center[0])
+    ordered = points[np.argsort(angles)]
+    start = int(np.argmin(ordered.sum(axis=1)))
+    ordered = np.roll(ordered, -start, axis=0)
+    if _signed_area(ordered) < 0:
+        ordered = ordered[[0, 3, 2, 1]]
+    return ordered.astype(np.float32)
+
+
+def scale_points(pts: PointSet, scale: float) -> np.ndarray:
+    points = _validate_points(pts)
+    if scale <= 0:
+        raise InvalidGeometryError("scale must be positive")
+    return points / float(scale)
+
+
+def four_point_transform(
+    image: np.ndarray,
+    pts: PointSet,
+    margin: int = 0,
+) -> tuple[np.ndarray, np.ndarray]:
+    if image is None or image.size == 0:
+        raise InvalidGeometryError("image cannot be empty")
+    if margin < 0:
+        raise InvalidGeometryError("margin cannot be negative")
+
+    rect = order_points(pts)
+    if abs(_signed_area(rect)) < 1e-6:
+        raise InvalidGeometryError("points do not define a valid quadrilateral")
+
+    tl, tr, br, bl = rect
+    width = max(np.linalg.norm(br - bl), np.linalg.norm(tr - tl))
+    height = max(np.linalg.norm(tr - br), np.linalg.norm(tl - bl))
+    width = round(width)
+    height = round(height)
+
+    if width < 2 or height < 2:
+        raise InvalidGeometryError("document quad is too small")
+
+    if margin > 0:
+        width += 2 * margin
+        height += 2 * margin
+
+    offset = float(margin)
+    max_x = float(width - 1)
+    max_y = float(height - 1)
+    dst = np.array(
+        [
+            [offset, offset],
+            [max_x - offset, offset],
+            [max_x - offset, max_y - offset],
+            [offset, max_y - offset],
+        ],
+        dtype=np.float32,
+    )
+
+    matrix = cv2.getPerspectiveTransform(rect, dst)
+    warped = cv2.warpPerspective(
+        image,
+        matrix,
+        (width, height),
+        flags=cv2.INTER_LINEAR,
+        borderMode=cv2.BORDER_REPLICATE,
+    )
+    return warped, matrix

csf_scraper/image_readers/adapters/cpu/open_cv_image_reader.py

@@ -0,0 +1,56 @@
+import asyncio
+import re
+
+import cv2
+import numpy as np
+
+from csf_scraper.exceptions.image_reader import ImageReadingException
+from csf_scraper.image_readers.adapters.cpu.open_cv.errors import ImageLoadError
+from csf_scraper.image_readers.adapters.cpu.open_cv.pipeline import scan_array
+from csf_scraper.image_readers.ports.image_reader_port import ImageReaderPort
+from csf_scraper.rfc_cif_data import RfcCifData
+from csf_scraper.value_objects.csf_image import CsfImage
+from csf_scraper.value_objects.id_cif import IdCif
+from csf_scraper.value_objects.rfc import Rfc
+
+
+class OpenCvImageReader(ImageReaderPort):
+    ID_CIF_RFC_PATTERN = r"D3=(\d+)_([A-Z&Ñ]{3,4}\d{6}[A-Z0-9]{3})"
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def _decode_image(self, image: bytes | bytearray | memoryview) -> np.ndarray:
+        if not isinstance(image, (bytes, bytearray, memoryview)):
+            raise TypeError("image must be bytes")
+        if len(image) == 0:
+            raise ImageLoadError("image cannot be empty")
+
+        buffer = np.frombuffer(image, dtype=np.uint8)
+        decoded = cv2.imdecode(buffer, cv2.IMREAD_COLOR)
+
+        if decoded is None:
+            raise ImageLoadError("could not decode image bytes")
+        return decoded
+
+    def _parse_id_cif_and_rfc(self, url: str) -> tuple[str, str]:
+        coincidence = re.search(self.ID_CIF_RFC_PATTERN, url)
+
+        if coincidence:
+            id_cif = coincidence.group(1)
+            rfc = coincidence.group(2)
+            return (id_cif, rfc)
+        raise ValueError("No se encontraron los datos en la URL.")
+
+    async def read(self, image: CsfImage) -> RfcCifData:
+        decoded = await asyncio.to_thread(self._decode_image, image.as_bytes())
+        result = await asyncio.to_thread(scan_array, decoded)
+
+        if not result.qr_code:
+            raise ImageReadingException(
+                "No fue posible leer el codigo QR, verifique la calidad de la imagen"
+            )
+
+        id_cif, rfc = self._parse_id_cif_and_rfc(result.qr_code)
+
+        return RfcCifData(id_cif=IdCif(id_cif), rfc=Rfc(rfc))

csf_scraper/scraper.py

@@ -29,8 +29,15 @@ class Scraper:
     Todo el flujo es asíncrono: la descarga usa un
     :class:`httpx.AsyncClient` y la extracción de datos se espera con
     ``await``. El cliente se puede cerrar con :meth:`aclose` o usando el
-    scraper como *async context manager*::
+    scraper como *async context manager*; usar ``async with`` es opcional::
 
+        scraper = Scraper.create()
+        try:
+            person = await scraper.obtain_from_rfc_and_cif(rfc, id_cif)
+        finally:
+            await scraper.aclose()
+
+        # Equivalente, cerrando al salir del bloque:
         async with Scraper.create() as scraper:
             person = await scraper.obtain_from_rfc_and_cif(rfc, id_cif)
     """
@@ -61,7 +68,9 @@ class Scraper:
     ) -> Self:
         """Crea un cliente HTTP asíncrono listo para usar contra el SAT."""
         return cls(
-            httpx.AsyncClient(follow_redirects=True, timeout=None, verify=_create_ssl_context()),
+            httpx.AsyncClient(
+                follow_redirects=True, timeout=None, verify=_create_ssl_context()
+            ),
             pdf_extractor=pdf_extractor,
             image_extractor=image_extractor,
         )
@@ -83,7 +92,9 @@ class Scraper:
         """Cierra el cliente HTTP subyacente."""
         await self.client.aclose()
 
-    async def obtain_from_rfc_and_cif(self, rfc: str, id_cif: str) -> PersonaMoral | PersonaFisica:
+    async def obtain_from_rfc_and_cif(
+        self, rfc: str, id_cif: str
+    ) -> PersonaMoral | PersonaFisica:
         """Obtiene la persona a partir de su RFC y su idCIF."""
         parsed_rfc = Rfc(rfc)
         parsed_cif = IdCif(id_cif)

{csf_scraper_python-0.1.1.dist-info → csf_scraper_python-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: csf-scraper-python
-Version: 0.1.1
+Version: 0.2.0
 Summary: Obtiene los datos fiscales actuales de una persona moral o física dado su RFC y su idCIF (port de phpcfdi/csf-scraper)
 Project-URL: Homepage, https://github.com/PJMP4826/csf-scraper-python
 Project-URL: Issues, https://github.com/PJMP4826/csf-scraper-python/issues
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Requires-Dist: beautifulsoup4>=4.12
@@ -35,9 +36,12 @@ Requires-Dist: ruff>=0.6; extra == 'dev'
 Provides-Extra: llm-gemini
 Requires-Dist: google-genai>=1.0; extra == 'llm-gemini'
 Requires-Dist: llama-index-llms-google-genai<0.12,>=0.11; extra == 'llm-gemini'
+Provides-Extra: opencv
+Requires-Dist: numpy>=2; extra == 'opencv'
+Requires-Dist: opencv-python-headless>=5.0; extra == 'opencv'
 Description-Content-Type: text/markdown
 
-# csf-scraper
+# csf-scraper-python
 
 Port a Python de [phpcfdi/csf-scraper](https://github.com/phpcfdi/csf-scraper):
 obtiene los datos fiscales actuales de una persona moral o física dado su RFC y
@@ -50,7 +54,8 @@ su idCIF (SAT, Constancia de Situación Fiscal).
   `poppler-utils`), necesario **solo** para leer la CSF desde un archivo PDF
   (`obtain_from_pdf_path`).
 - Dependencias: `httpx`, `beautifulsoup4`, `lxml`, `pydantic`, `llama-index-core`.
-  Los clientes de cada proveedor LLM son extras opcionales (`llm-gemini`).
+  Los clientes de cada proveedor LLM son extras opcionales (`llm-gemini`). El
+  lector de imágenes basado en OpenCV requiere el extra `opencv`.
 
 ## Instalación
 
@@ -66,6 +71,12 @@ Para leer CSF escaneadas (JPEG/PNG) con Gemini, agrega el extra:
 pip install "csf-scraper-python[llm-gemini]"
 ```
 
+Para leerlas usando el lector basado en OpenCV:
+
+```bash
+pip install "csf-scraper-python[opencv]"
+```
+
 Desde el código fuente:
 
 ```bash
@@ -77,6 +88,10 @@ pip install .
 Todo el flujo es asíncrono: `Scraper` envuelve un `httpx.AsyncClient` y todos
 los métodos de lectura son corrutinas, así que se consumen con `await`.
 
+`Scraper.create()` crea y devuelve la instancia directamente; **no** es
+obligatorio usarla con `async with`. Basta con cerrar el cliente al terminar,
+ya sea llamando a `aclose()` o usando el scraper como _async context manager_:
+
 ```python
 import asyncio
 
@@ -84,14 +99,17 @@ from csf_scraper import Scraper
 
 
 async def main() -> None:
-    # El scraper es un context manager asíncrono: cierra el AsyncClient al salir
-    async with Scraper.create() as scraper:
+    scraper = Scraper.create()
+
+    try:
         # RFC + idCIF directamente (se validan con los value objects Rfc e IdCif)
         person = await scraper.obtain_from_rfc_and_cif("DIM8701081LA", "1904014102123")
 
         # También puedes obtener los datos directamente de un archivo local PDF
         # (requiere pdftotext / poppler-utils instalado)
         person = await scraper.obtain_from_pdf_path("ruta/al/csf.pdf")
+    finally:
+        await scraper.aclose()
 
     # Acceso a los datos de la persona (moral o física) por atributos
     if person.is_fisica():
@@ -115,6 +133,16 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
+Si prefieres no gestionar el cierre manualmente, el scraper también funciona
+como _async context manager_ (cierra el `AsyncClient` al salir del bloque):
+
+```python
+async def main() -> None:
+    async with Scraper.create() as scraper:
+        person = await scraper.obtain_from_rfc_and_cif("DIM8701081LA", "1904014102123")
+    print(person.to_dict())
+```
+
 Para leer una CSF escaneada (JPEG/PNG) se inyecta el motor de lectura de imágenes.
 Requiere el extra `llm-gemini`:
 
@@ -126,8 +154,33 @@ from csf_scraper import CsfImageExtractor, GeminiImageReader, Scraper
 
 async def main() -> None:
     reader = GeminiImageReader(api_key="…", model_name="…")
-    async with Scraper.create(image_extractor=CsfImageExtractor(reader)) as scraper:
+    scraper = Scraper.create(image_extractor=CsfImageExtractor(reader))
+    try:
+        person = await scraper.obtain_from_image_path("ruta/al/csf.png")
+    finally:
+        await scraper.aclose()
+    print(person.to_dict())
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Para usar el lector basado en OpenCV no se necesita un proveedor LLM. Requiere
+el extra `opencv`:
+
+```python
+import asyncio
+
+from csf_scraper import CsfImageExtractor, OpenCvImageReader, Scraper
+
+
+async def main() -> None:
+    scraper = Scraper.create(image_extractor=CsfImageExtractor(OpenCvImageReader()))
+    try:
         person = await scraper.obtain_from_image_path("ruta/al/csf.png")
+    finally:
+        await scraper.aclose()
     print(person.to_dict())
 
 
@@ -135,14 +188,31 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
-Salida de `person.to_dict()` para una persona moral (fechas como `datetime`):
+`to_dict()` devuelve el conjunto completo de propiedades del modelo que se haya
+obtenido: los campos comunes de `Persona` más los propios de `PersonaMoral` o de
+`PersonaFisica`. Las fechas se devuelven como `datetime` (o `None`) y los value
+objects `Rfc`/`IdCif` como cadenas.
+
+Salida de `person.to_dict()` para una **persona moral**:
 
 ```python
 {
+    # Compartidos con PersonaFisica
     "rfc": "DIM8701081LA",
     "id_cif": "12345678",
     "fecha_inicio_operaciones": datetime(2019, 2, 21),
-    # …
+    "situacion_contribuyente": "ACTIVO",
+    "fecha_ultimo_cambio_situacion": datetime(2019, 2, 21),
+    "entidad_federativa": "CIUDAD DE MEXICO",
+    "municipio_delegacion": "CUAUHTEMOC",
+    "colonia": "CENTRO",
+    "tipo_vialidad": "CALLE",
+    "nombre_vialidad": "AVENIDA REFORMA",
+    "numero_exterior": "123",
+    "numero_interior": "A",
+    "codigo_postal": "06000",
+    "correo_electronico": "contacto@ejemplo.mx",
+    "al": "CIUDAD DE MEXICO",
     "regimenes": [
         {
             "regimen": "Régimen General de Ley Personas Morales",
@@ -151,12 +221,53 @@ Salida de `person.to_dict()` para una persona moral (fechas como `datetime`):
         },
     ],
     "extra_data": {"localidad": ""},
+    # Propios de PersonaMoral
     "razon_social": "Mi razón social",
     "regimen_de_capital": "SA DE CV",
     "fecha_constitucion": datetime(2019, 2, 21),
 }
 ```
 
+Salida de `person.to_dict()` para una **persona física**:
+
+```python
+{
+    # Compartidos con PersonaMoral
+    "rfc": "GODE561231GR8",
+    "id_cif": "12345678",
+    "fecha_inicio_operaciones": datetime(2019, 2, 21),
+    "situacion_contribuyente": "ACTIVO",
+    "fecha_ultimo_cambio_situacion": datetime(2019, 2, 21),
+    "entidad_federativa": "CIUDAD DE MEXICO",
+    "municipio_delegacion": "CUAUHTEMOC",
+    "colonia": "CENTRO",
+    "tipo_vialidad": "CALLE",
+    "nombre_vialidad": "AVENIDA REFORMA",
+    "numero_exterior": "123",
+    "numero_interior": "A",
+    "codigo_postal": "06000",
+    "correo_electronico": "contacto@ejemplo.mx",
+    "al": "CIUDAD DE MEXICO",
+    "regimenes": [
+        {
+            "regimen": "Régimen de Sueldos y Salarios e Ingresos Asimilados a Salarios",
+            "fecha_alta": datetime(2019, 2, 21),
+            "regimen_id": "605",
+        },
+    ],
+    "extra_data": {"localidad": ""},
+    # Propios de PersonaFisica
+    "curp": "GODE561231HDFRRN09",
+    "nombre": "MI NOMBRE",
+    "apellido_paterno": "MI APELLIDO PATERNO",
+    "apellido_materno": "MI APELLIDO MATERNO",
+    "fecha_nacimiento": datetime(1956, 12, 31),
+}
+```
+
+Si necesitas las fechas en ISO-8601, usa `person.model_dump_json()`, que
+serializa exactamente las mismas propiedades.
+
 ## Modelos
 
 - `Persona` es la base de `PersonaFisica` y `PersonaMoral`; sus campos se

{csf_scraper_python-0.1.1.dist-info → csf_scraper_python-0.2.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-csf_scraper/__init__.py,sha256=PaumGzitsC5f_ZzITtAcc7rGqEE9Leo3Z1C5RnvVg2s,3623
+csf_scraper/__init__.py,sha256=gfQWtIIgLA7l9uJGTahDPmwMUP2K1T0l6BWnhbMdkJU,3873
 csf_scraper/data_extractor.py,sha256=c2d48ISxK_-yFViRCdZ6Vfqrv7PChrdr3MNpoxrZ2oA,2815
 csf_scraper/date_parser.py,sha256=bQpBXhA-Git3dOVdij98pqj1ScDU0DmQdB1rNgO9tUk,797
 csf_scraper/persona.py,sha256=ZOiO4WEbufA4teRm265GuRlW2oCCcyUhmKJRBA-wJwo,2445
@@ -7,7 +7,7 @@ csf_scraper/persona_moral.py,sha256=4CHSmVqvxVf2xD6XMZ5Ij0NuOX4DOwBKTpgw9b7fyp4,
 csf_scraper/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 csf_scraper/regimen.py,sha256=r0_wblU4dMNvkc0KoAaQ6P10oGTDBuSIm_RhDMsnxeo,2180
 csf_scraper/rfc_cif_data.py,sha256=7UHNocdf-y8Cpb0BHtOt5JAazZ-aCOg019aWUPJTa9Q,404
-csf_scraper/scraper.py,sha256=FqAxYFaXgCM7D1DhkTS2H3CSJ8BnKSs2DWAoK-HS9fI,4418
+csf_scraper/scraper.py,sha256=2_mivEQ7j1qtB-Qo36FRu5IsvMCT9atbks9Ga0D7ZII,4721
 csf_scraper/exceptions/__init__.py,sha256=Rio4OEagZmAmxge1TQ4CsjhyUY1QEvLca3Uor9SFGo4,506
 csf_scraper/exceptions/image_reader.py,sha256=Acu0iCF11Z6XKpeSNn-s8HRfWzM-4RESdOYNmX-Wdq0,3529
 csf_scraper/exceptions/pdf_reader.py,sha256=zkPv7gbsvWO-Vs7vc_stt8YbG_PTLDoq_Nibeh9vvZk,845
@@ -15,6 +15,17 @@ csf_scraper/exceptions/value_objects.py,sha256=Kc2FUWud_Tc_LBhgGUMebO67ScI1CbNUQ
 csf_scraper/image_readers/__init__.py,sha256=0RRLSc0nOurpV8DwE4h5d6hUlYjvuGxrjKsoXAVOr_Q,1591
 csf_scraper/image_readers/csf_image_extractor.py,sha256=wnQFUI1BADAlbni0qK98bQhP6saGw6tq1fL-amqPWP8,1271
 csf_scraper/image_readers/adapters/__init__.py,sha256=tO-N2ZCUo1E751TeHVkvLO1wWxUbEkG8PT8KryFxGGU,534
+csf_scraper/image_readers/adapters/cpu/__init__.py,sha256=Fv1sPhwSitujYCMTeNB1tD7_LEurUlfXVDsauSlawf4,574
+csf_scraper/image_readers/adapters/cpu/open_cv_image_reader.py,sha256=cIh4oNSj1_j_fTmX9YiI6S64wfxKPHqPyTgOCPoGuPc,2092
+csf_scraper/image_readers/adapters/cpu/open_cv/__init__.py,sha256=5W264aq2TJnoDMM2662rV5LGbyErh6KSqNjbPkuTeFs,925
+csf_scraper/image_readers/adapters/cpu/open_cv/config.py,sha256=XjSNW-W3ptoMLCpHupRmU_vjyP2illX3JXtup_soeUE,3302
+csf_scraper/image_readers/adapters/cpu/open_cv/detection.py,sha256=hY_dwANd-nALpg2mmA-f9WDPs92pDd80UVjTZLOQ7Os,8132
+csf_scraper/image_readers/adapters/cpu/open_cv/enhance.py,sha256=m9KYpWx5cPhfDbhcmvY3k8-XLi3NI0KRT9R-0vTgj2g,3285
+csf_scraper/image_readers/adapters/cpu/open_cv/errors.py,sha256=pvtlyNgrTvgkRLmH9aH2BO4dveTe4PlYaDIQoM4tgm4,281
+csf_scraper/image_readers/adapters/cpu/open_cv/io.py,sha256=xB13TzBKFrHiikv4U1q2cpIbW6FIte7JTKLclFK5ukU,886
+csf_scraper/image_readers/adapters/cpu/open_cv/pipeline.py,sha256=SLMKxcDTooASZFHV9SIEaIhAlv_EokV75wzbEKHQ3xs,2548
+csf_scraper/image_readers/adapters/cpu/open_cv/qr.py,sha256=Gj8xpG9biEQC3LBr7jUvV8px-RlCLggABeGH05jUKaE,3041
+csf_scraper/image_readers/adapters/cpu/open_cv/transform.py,sha256=aRIvqauAWQXGMpyIASuqjfoIqIF7W5AppJTH6jy-h5w,2882
 csf_scraper/image_readers/adapters/llms/__init__.py,sha256=FR0OzKO5lxMriOGS_MYaSd9RoNJ30-HaEsN7YvIGIug,1139
 csf_scraper/image_readers/adapters/llms/gemini_image_reader.py,sha256=NCTlBBVsNUNhmSHX7ZixZaBqlkTSz1ds40RZFXpGVbw,6003
 csf_scraper/image_readers/adapters/llms/prompts/__init__.py,sha256=tGau_NVzj8qxgfkq4IW8qNZC4XJ267NGZKbuHdXoizA,240
@@ -35,8 +46,8 @@ csf_scraper/value_objects/__init__.py,sha256=fksrywY6MHNYgSKpy6VLWXMvdfXi8Tjx3xR
 csf_scraper/value_objects/csf_image.py,sha256=RzU0ZO8JomxYVPTaqARXaI_NV76ZO2zM5N_PforNE8A,2332
 csf_scraper/value_objects/id_cif.py,sha256=8ZVVPgNEM_AeEVe-dk8x0b-x1NObW9bNhMGNVD3R6LU,1564
 csf_scraper/value_objects/rfc.py,sha256=jLkrF0_DKC6ETV66GQFQNU3BiBxRh9ffaHdPciDoCn0,1987
-csf_scraper_python-0.1.1.dist-info/METADATA,sha256=YNQ51ihu850s_QccnXaVP54Y2gzdSZDB38cp6b66V74,14955
-csf_scraper_python-0.1.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-csf_scraper_python-0.1.1.dist-info/licenses/LICENSE,sha256=c9W1BLxpJQUZ21EogN1_nyVGgB0SdXqmpc5c0lvpnQI,1106
-csf_scraper_python-0.1.1.dist-info/licenses/NOTICE.md,sha256=-0Mi9rUvfhYtXNRnDlX3SZAv8K3zU2okd5e4vg4q_sA,901
-csf_scraper_python-0.1.1.dist-info/RECORD,,
+csf_scraper_python-0.2.0.dist-info/METADATA,sha256=I2aljSP3CFwWcqf7bkGxrm-fJE3OK4kKXkfOU58LyYE,18472
+csf_scraper_python-0.2.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+csf_scraper_python-0.2.0.dist-info/licenses/LICENSE,sha256=c9W1BLxpJQUZ21EogN1_nyVGgB0SdXqmpc5c0lvpnQI,1106
+csf_scraper_python-0.2.0.dist-info/licenses/NOTICE.md,sha256=-0Mi9rUvfhYtXNRnDlX3SZAv8K3zU2okd5e4vg4q_sA,901
+csf_scraper_python-0.2.0.dist-info/RECORD,,

{csf_scraper_python-0.1.1.dist-info → csf_scraper_python-0.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.32.4
+Generator: hatchling 1.33.0
 Root-Is-Purelib: true
 Tag: py3-none-any