mrblack

 71def extract_pii_text(
 72    text: str,
 73    labels: Optional[Union[List[str], str]] = None
 74) -> Dict[str, List[str]]:
 75    """
 76    Extract PII matches from provided text.
 77
 78    Args:
 79        text (str): The input text to scan for patterns.
 80        labels (Optional[Union[List[str], str]]): Specific labels to filter on.
 81
 82    Returns:
 83        Dict[str, List[str]]: Mapping of each label to a sorted list of
 84        matched and cleaned strings.
 85    """
 86    if isinstance(labels, str):
 87        labels = [labels]
 88    patterns = PATTERNS
 89    if labels:
 90        patterns = [
 91            p for p in PATTERNS
 92            if any(re.search(rf"\(\?P<{lbl}>", p) for lbl in labels)
 93        ]
 94    results: Dict[str, set] = defaultdict(set)
 95    for pattern in patterns:
 96        try:
 97            rx = re.compile(pattern)
 98            for m in rx.finditer(text):
 99                for lbl, val in m.groupdict().items():
100                    if not val:
101                        continue
102                    cleaned = _clean_value(lbl, val)
103                    if lbl == "url":
104                        cleaned = cleaned.rstrip("),.**")
105                    if cleaned is not None:
106                        results[lbl].add(cleaned)
107        except re.error as e:
108            print(
109                f"Invalid regex skipped: {pattern} → {e}",
110                file=sys.stderr
111            )
112    return {lbl: sorted(vals) for lbl, vals in results.items()}

115def extract_pii_file(
116    file_path: str,
117    labels: Optional[Union[List[str], str]] = None
118) -> Optional[Dict[str, List[str]]]:
119    """
120    Extract PII from a single file's text content.
121
122    Args:
123        file_path (str): Path to the file.
124        labels (Optional[Union[List[str], str]]): Labels to filter.
125
126    Returns:
127        Optional[Dict[str, List[str]]]: Extraction results, or None.
128    """
129    text = extract_text(file_path)
130    if not text:
131        return None
132    data = extract_pii_text(text, labels)
133    return data or None

136def extract_pii_url(
137    path: str,
138    labels: Optional[Union[List[str], str]] = None
139) -> Optional[Dict[str, List[str]]]:
140    """
141    Extract PII from the text at a URL.
142
143    Args:
144        path (str): The URL to fetch.
145        labels (Optional[Union[List[str], str]]): Labels to filter.
146
147    Returns:
148        Optional[Dict[str, List[str]]]: Extraction results, or None.
149    """
150    text = text_from_url(path)
151    if not text:
152        return None
153    data = extract_pii_text(text, labels)
154    return data or None

157def extract_pii_image(
158    image_path: str,
159    labels: Optional[Union[List[str], str]] = None
160) -> Optional[Dict[str, List[str]]]:
161    """
162    Extract PII from an image using OCR.
163
164    Args:
165        image_path (str): Path to the image file.
166        labels (Optional[Union[List[str], str]]): Labels to filter.
167
168    Returns:
169        Optional[Dict[str, List[str]]]: Extraction results, or None.
170    """
171    path = clean_path(image_path)
172    if not path or not os.path.isfile(path):
173        print(f"[red]Invalid image path:[/] {image_path}")
174        return None
175    text = extract_text(path)
176    if not text:
177        return None
178    data = extract_pii_text(text, labels)
179    return data or None

182def extract_pii_screenshot(
183    labels: Optional[Union[List[str], str]] = None
184) -> Optional[Dict[str, List[str]]]:
185    """
186    Capture a screenshot and extract PII from its OCR text.
187
188    Args:
189        labels (Optional[Union[List[str], str]]): Labels to filter.
190
191    Returns:
192        Optional[Dict[str, List[str]]]: Extraction results, or None.
193    """
194    text = text_from_screenshot()
195    if not text:
196        return None
197    data = extract_pii_text(text, labels)
198    return data or None

566def extract_text_with_password(file_path: str, password: str) -> Optional[str]:
567    """
568    Extract text from password-protected files.
569    
570    Args:
571        file_path (str): Path to the file
572        password (str): Password to unlock the file
573        
574    Returns:
575        Optional[str]: Extracted text
576    """
577    file_ext = os.path.splitext(file_path)[1].lower()
578    
579    if file_ext == '.pdf':
580        return text_from_pdf_protected(file_path, password)
581    elif file_ext in ['.docx', '.xlsx', '.pptx']:
582        return text_from_office_protected(file_path, password)
583    else:
584        logger.warning(f"Password protection not supported for {file_ext} files")
585        return None

480def extract_text(
481    file_path: str
482) -> Optional[str]:
483    """
484    Extract text content from a local file or URL.
485
486    Supports web pages, text, JSON, XML, CSV, Excel, PDF, DOCX, images, audio.
487
488    Args:
489        file_path (str): Path to the input file or URL.
490
491    Returns:
492        Optional[str]: Extracted text, or None if unsupported or error.
493    """
494    if is_url(file_path):
495        return text_from_url(file_path)
496
497    TEXT_MIME_TYPES = {
498        "application/json", "application/xml", "application/x-yaml",
499        "application/x-toml", "application/x-csv", "application/x-markdown",
500    }
501
502    path = clean_path(file_path)
503    if not path:
504        logger.error(f"No such file: {file_path}")
505        return None
506
507    mime_type = magic.from_file(path, mime=True)
508    try:
509        if mime_type.startswith("text/html"):
510            content = text_from_html(path)
511            return content
512
513        elif mime_type.startswith("text/") or mime_type in TEXT_MIME_TYPES:
514            with open(path, 'r', encoding='utf-8', errors='ignore') as f:
515                content = f.read()
516            return normalize_text(content)
517
518        elif mime_type in [
519            "application/vnd.ms-excel",
520            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
521        ]:
522            content = text_from_excel(path)
523            return content
524
525        elif mime_type == "application/pdf":
526            content = text_from_pdf(path)
527            return content
528
529        elif mime_type == \
530            "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
531            content = text_from_docx(path)
532            return content
533
534        elif mime_type == "application/msword":
535            content = text_from_doc(path)
536            return content
537
538        elif mime_type.startswith("image/"):
539            content = text_from_image(path)
540            return content
541
542        elif mime_type.startswith("audio/"):
543            content = text_from_audio(path)
544            return content
545
546        elif mime_type == "application/epub+zip":
547            content = text_from_epub(path)
548            return content
549
550        elif mime_type == "application/vnd.openxmlformats-officedocument.presentationml.presentation":
551            content = text_from_pptx(path)
552            return content
553
554        elif mime_type == "application/vnd.oasis.opendocument.text":
555            content = text_from_odt(path)
556            return content
557
558        else:
559            content = text_from_any(path)
560            return content
561    except Exception as e:
562        logger.error(f"Error reading {path}: {e}")
563        return None

248def extract_exif(
249    file_path: str
250) -> Optional[Dict[str, Any]]:
251    """
252    Extract EXIF metadata from a file using exiftool.
253
254    Args:
255        file_path (str): Path to the target file.
256
257    Returns:
258        Optional[Dict[str, Any]]: Parsed EXIF data, or None on failure.
259    """
260    exif_data: Optional[Dict[str, Any]] = None
261    try:
262        result = subprocess.run(
263            ['exiftool', '-j', file_path],
264            stdout=subprocess.PIPE,
265            stderr=subprocess.PIPE
266        )
267        if result.returncode == 0:
268            exif_data = json.loads(result.stdout.decode())[0]
269    except Exception as e:
270        logger.error(f"Exiftool failed: {e}")
271    return exif_data

1965def extract_metadata(source: str) -> dict:
1966    """
1967    Central metadata extraction router.  Routes metadata extraction based on the source.
1968
1969    Args:
1970        source (str): source to extract metadata from
1971
1972    Returns:
1973        dict: Dictionary of extracted metadata for the given source.
1974    """
1975    if is_url(source):
1976        metadata = extract_url_metadata(source)
1977    else:
1978        metadata = extract_file_metadata(source)
1979
1980    return metadata

1071def extract_strings(file_path, min_length=4):
1072    """
1073    Extract printable strings from a file, similar to the Unix 'strings' command.
1074    
1075    Args:
1076        file_path (str): Path to the file to extract strings from
1077        min_length (int, optional): Minimum length of strings to extract. Defaults to 4.
1078        
1079    Returns:
1080        list: List of printable strings found in the file
1081    """
1082    file_path = clean_path(file_path)
1083
1084    
1085    # Define printable characters (excluding tabs and newlines)
1086    printable_chars = set(string.printable) - set('\t\n\r\v\f')
1087    
1088    result = []
1089    current_string = ""
1090    
1091    # Read the file in binary mode
1092    try:
1093        with open(file_path, 'rb') as file:
1094            # Read the file byte by byte
1095            for byte in file.read():
1096                # Convert byte to character
1097                char = chr(byte)
1098                
1099                # If character is printable, add to current string
1100                if char in printable_chars:
1101                    current_string += char
1102                # If not printable and we have a string of minimum length, add to results
1103                elif len(current_string) >= min_length:
1104                    if current_string == "Sj[d":
1105                        pass
1106                    else:
1107                        result.append(current_string)
1108                    current_string = ""
1109                # If not printable and current string is too short, reset current string
1110                else:
1111                    current_string = ""
1112        
1113        # Don't forget to add the last string if it meets the minimum length
1114        if len(current_string) >= min_length:
1115            result.append(current_string)
1116        
1117        return result
1118    except FileNotFoundError:
1119        print(f"Error: File '{file_path}' not found.", file=sys.stderr)
1120        return None
1121    except Exception as e:
1122        print(f"Error: {e}", file=sys.stderr)
1123        return None

214def text_from_screenshot() -> str:
215    """
216    Capture a full-screen screenshot, perform OCR, and clean up temp file.
217
218    Returns:
219        str: Normalized OCR-extracted text from the screenshot.
220    """
221    tmp_filename = f"screenshot_{uuid4().hex}.png"
222    tmp_path = os.path.join(tempfile.gettempdir(), tmp_filename)
223
224    try:
225        with mss() as sct:
226            monitor = {"top": 0, "left": 0, "width": 0, "height": 0}
227            for mon in sct.monitors:
228                monitor["left"] = min(mon["left"], monitor["left"])
229                monitor["top"] = min(mon["top"], monitor["top"])
230                monitor["width"] = max(mon["width"] + mon["left"] - monitor["left"], monitor["width"])
231                monitor["height"] = max(mon["height"] + mon["top"] - monitor["top"], monitor["height"])
232            screenshot = sct.grab(monitor)
233
234        img = Image.frombytes("RGB", screenshot.size, screenshot.bgra, "raw", "BGRX")
235        img_gray = img.convert("L")
236        img_gray.save(tmp_path)
237
238        content = text_from_image(tmp_path)
239        return normalize_text(content)
240    finally:
241        if os.path.exists(tmp_path):
242            try:
243                os.remove(tmp_path)
244            except Exception as e:
245                logger.error(f"Failed to delete temp screenshot: {e}")

355def text_from_url(
356    url: str,
357    render_js: bool = True
358) -> Optional[str]:
359    """
360    Extract visible text from a web page or downloadable file at the given URL.
361
362    Args:
363        url (str): Target URL (web page or file).
364        render_js (bool): Whether to render JavaScript content.
365
366    Returns:
367        Optional[str]: Extracted text, or None on failure.
368    """
369    headers = generate_http_headers(url)
370
371    # Attempt to detect content type
372    content_type = ""
373    try:
374        head = requests.head(url, headers=headers, timeout=5, allow_redirects=True)
375        content_type = head.headers.get("Content-Type", "").lower()
376    except Exception as e:
377        logger.warning(f"HEAD request failed: {e}")
378        try:
379            resp = requests.get(url, headers=headers, timeout=5, stream=True)
380            content_type = resp.headers.get("Content-Type", "").lower()
381        except Exception as e:
382            logger.warning(f"GET fallback for Content-Type check failed: {e}")
383
384    # If clearly not HTML, treat as a file and extract locally
385    if not content_type.startswith("text/html"):
386        try:
387            with requests.get(url, headers=headers, stream=True, timeout=15) as r:
388                r.raise_for_status()
389                suffix = Path(urlparse(url).path).suffix or ".bin"
390                with tempfile.NamedTemporaryFile(delete=False, suffix=suffix, dir="/tmp") as tmp_file:
391                    shutil.copyfileobj(r.raw, tmp_file)
392                    tmp_path = tmp_file.name
393            return extract_text(tmp_path)
394        except Exception as e:
395            logger.error(f"Failed to download and extract file from URL: {url} - {e}")
396            return None
397
398    # Standard HTML path
399    if render_js:
400        try:
401            session = HTMLSession()
402            try:
403                r = session.get(url, headers=headers, timeout=5)
404                try:
405                    r.html.render(timeout=5, sleep=1, keep_page=True)
406                except Exception as e:
407                    logger.warning(f"JS rendering failed, falling back to static HTML: {e}")
408                html = r.html.html
409                return text_from_html(html)
410            except Exception as e:
411                logger.error(f"[Error with HTMLSession] {url} - {e}")
412            finally:
413                session.close()
414        except Exception as e:
415            logger.error(f"[Error creating HTMLSession] {e}")
416
417    # Fallback: static HTML without rendering
418    try:
419        response = requests.get(url, headers=headers, timeout=10)
420        response.raise_for_status()
421        html = response.text
422        return text_from_html(html)
423    except Exception as e:
424        logger.error(f"[Error with requests] {url} - {e}")
425        return None

322def text_from_html(html: str) -> str:
323    """
324    Extract readable text from raw HTML content.
325
326    Args:
327        html (str): HTML source as a string.
328
329    Returns:
330        str: Cleaned and normalized visible text.
331    """
332    # Check if the input is a file path or HTML content
333    if os.path.isfile(html):
334        with open(html, 'r', encoding='utf-8', errors='ignore') as f:
335            html = f.read()
336    
337    soup = BeautifulSoup(html, "html.parser")
338
339    # Remove non-visible or structural elements
340    for tag in soup([
341        "script", "style",
342        "noscript", "iframe",
343        "meta", "link",
344        "header", "footer",
345        "form", "nav",
346        "aside"
347    ]):
348        tag.decompose()
349
350    text = soup.get_text(separator=" ")
351
352    return normalize_text(text)

629def text_from_audio(
630    audio_file: str
631) -> Optional[str]:
632    """
633    Transcribe audio to text using Google Speech Recognition.
634
635    Args:
636        audio_file (str): Path to the input audio file.
637
638    Returns:
639        Optional[str]: Transcription, or None on failure.
640    """
641    def convert_to_wav(file_path: str) -> str:
642        _, ext = os.path.splitext(file_path)
643        ext = ext.lstrip('.')
644        audio = AudioSegment.from_file(file_path, format=ext)
645        tmp_filename = f"audio_{uuid4().hex}.wav"
646        wav_path = os.path.join(tempfile.gettempdir(), tmp_filename)
647        audio.export(wav_path, format='wav')
648        return wav_path
649
650    recognizer = sr.Recognizer()
651    temp_wav_path = None
652    cleanup_needed = False
653
654    try:
655        _, ext = os.path.splitext(audio_file)
656        if ext.lower() not in ['.wav', '.wave']:
657            temp_wav_path = convert_to_wav(audio_file)
658            cleanup_needed = True
659        else:
660            temp_wav_path = clean_path(audio_file)
661
662        if not temp_wav_path:
663            logger.error("Invalid audio path.")
664            return None
665
666        with sr.AudioFile(temp_wav_path) as source:
667            audio = recognizer.record(source)
668        return recognizer.recognize_google(audio)
669
670    except sr.UnknownValueError:
671        logger.error("Could not understand audio.")
672    except sr.RequestError as e:
673        logger.error(f"Speech recognition error: {e}")
674    except Exception as e:
675        logger.error(f"Failed to process audio: {e}")
676    finally:
677        if cleanup_needed and temp_wav_path and os.path.exists(temp_wav_path):
678            try:
679                os.remove(temp_wav_path)
680            except Exception as e:
681                logger.error(f"Failed to delete temp WAV file {temp_wav_path}: {e}")
682
683    return None

743def text_from_pdf(
744    pdf_path: str
745) -> Optional[str]:
746    """
747    Extract text and OCR results from a PDF using PyMuPDF.
748
749    Args:
750        pdf_path (str): Path to PDF file.
751
752    Returns:
753        Optional[str]: Combined normalized text and image OCR results.
754    """
755    plain_text = ""
756    temp_image_paths: List[str] = []
757
758    try:
759        doc = pymupdf.open(pdf_path)
760        for k, v in doc.metadata.items():
761            plain_text += f"{k}: {v}\n"
762
763        for i in range(len(doc)):
764            page = doc.load_page(i)
765            plain_text += f"\n--- Page {i + 1} ---\n"
766            text = page.get_text()
767            plain_text += text or "[No text]\n"
768
769            for img_index, img in enumerate(page.get_images(full=True), start=1):
770                xref = img[0]
771                base = doc.extract_image(xref)
772                img_bytes = base["image"]
773
774                img_filename = f"pdf_page{i+1}_img{img_index}_{uuid4().hex}.png"
775                img_path = os.path.join(tempfile.gettempdir(), img_filename)
776                temp_image_paths.append(img_path)
777
778                with open(img_path, "wb") as f:
779                    f.write(img_bytes)
780
781                ocr = text_from_image(img_path) or ""
782                plain_text += f"\n[Image {img_index} OCR]\n{ocr}\n"
783
784        # Extract tables from PDF
785        """
786        try:
787            tables = extract_tables_from_pdf(pdf_path)
788            if tables:
789                plain_text += "\n--- Tables ---\n"
790                for i, table in enumerate(tables, 1):
791                    plain_text += f"\n[Table {i}]\n"
792                    if isinstance(table, dict) and "data" in table:
793                        for row in table["data"]:
794                            plain_text += str(row) + "\n"
795                    else:
796                        plain_text += str(table) + "\n"
797        except Exception as e:
798            logger.warning(f"Could not extract tables from PDF: {e}")
799        """
800
801        return normalize_text(plain_text)
802    except Exception as e:
803        logger.error(f"Error processing PDF: {e}")
804        return None
805    finally:
806        for path in temp_image_paths:
807            if os.path.exists(path):
808                try:
809                    os.remove(path)
810                except Exception as e:
811                    logger.error(f"Failed to delete temp image {path}: {e}")
812        if 'doc' in locals():
813            doc.close()

891def text_from_doc(
892    filepath: str,
893    min_length: int = 4
894) -> str:
895    """
896    Extract readable strings and metadata from binary Word (.doc) files.
897
898    Args:
899        filepath (str): Path to .doc file.
900        min_length (int): Minimum string length to extract.
901
902    Returns:
903        str: Metadata and text content.
904    """
905    def extract_printable_strings(
906        data: bytes
907    ) -> List[str]:
908        pattern = re.compile(
909            b'[' + re.escape(bytes(string.printable, 'ascii')) +
910            b']{%d,}' % min_length
911        )
912        found = pattern.findall(data)
913
914        results = []
915        for m in found:
916            value = m.decode(errors='ignore').strip()
917            results.append(value)
918
919        return results
920
921    def clean_strings(
922        strs: List[str]
923    ) -> List[str]:
924        cleaned: List[str] = []
925        skip = ["HYPERLINK", "OLE2", "Normal.dotm"]
926        for line in strs:
927            if any(line.startswith(pref) for pref in skip):
928                continue
929            cleaned.append(re.sub(r'\s+', ' ', line).strip())
930        return cleaned
931
932    with open(filepath, 'rb') as f:
933        data = f.read()
934
935    strings = extract_printable_strings(data)
936    strings = clean_strings(strings)
937    content = "\n".join(strings)
938
939    return normalize_text(content)

942def text_from_docx(
943    file_path: str
944) -> Optional[str]:
945    """
946    Extract text, tables, and OCR from embedded images in a DOCX file.
947
948    Args:
949        file_path (str): Path to the .docx file.
950
951    Returns:
952        Optional[str]: Normalized full text content.
953    """
954    path = clean_path(file_path)
955    if not path:
956        return None
957
958    temp_image_paths: List[str] = []
959    plain_text = ""
960
961    try:
962        doc = Document(path)
963
964        for p in doc.paragraphs:
965            if p.text.strip():
966                plain_text += p.text.strip() + "\n"
967
968        for tbl in doc.tables:
969            plain_text += "\n[Table]\n"
970            for row in tbl.rows:
971                row_text = "\t".join(c.text.strip() for c in row.cells)
972                plain_text += row_text + "\n"
973
974        for rel_id, rel in doc.part.rels.items():
975            if "image" in rel.target_ref:
976                blob = rel.target_part.blob
977
978                img_filename = f"docx_img_{rel_id}_{uuid4().hex}.png"
979                img_path = os.path.join(tempfile.gettempdir(), img_filename)
980                temp_image_paths.append(img_path)
981
982                with open(img_path, "wb") as img_file:
983                    img_file.write(blob)
984
985                ocr = text_from_image(img_path) or ""
986                plain_text += f"\n[Image OCR]\n{ocr}\n"
987
988        return normalize_text(plain_text)
989
990    except Exception as e:
991        logger.error(f"Error processing DOCX: {e}")
992        return None
993    finally:
994        for path in temp_image_paths:
995            if os.path.exists(path):
996                try:
997                    os.remove(path)
998                except Exception as e:
999                    logger.error(f"Failed to delete temp DOCX image {path}: {e}")

1002def text_from_excel(
1003    file_path: str
1004) -> str:
1005    """
1006    Convert an Excel workbook to CSV text.
1007
1008    Args:
1009        file_path (str): Path to the Excel file.
1010
1011    Returns:
1012        str: CSV-formatted string.
1013    """
1014    path = clean_path(file_path)
1015    if not path:
1016        return ""
1017    try:
1018        # Get all sheets
1019        result = ""
1020        excel_file = pd.ExcelFile(path)
1021        for sheet_name in excel_file.sheet_names:
1022            df = pd.read_excel(path, sheet_name=sheet_name)
1023            out = StringIO()
1024            df.to_csv(out, index=False)
1025            result += f"\n--- Sheet: {sheet_name} ---\n"
1026            result += out.getvalue()
1027            result += "\n"
1028        return result
1029    except Exception as e:
1030        logger.error(f"Failed Excel -> CSV: {e}")
1031        return ""

1034def text_from_image(
1035    file_path: str
1036) -> Optional[str]:
1037    """
1038    Perform OCR on an image file.
1039
1040    Args:
1041        file_path (str): Path to the image.
1042
1043    Returns:
1044        Optional[str]: Extracted text, or None on error.
1045    """
1046    path = clean_path(file_path)
1047    if not path:
1048        return None
1049    try:
1050        with Image.open(path) as img:
1051            # Improve OCR with preprocessing
1052            # 1. Convert to grayscale if it's not already
1053            if img.mode != 'L':
1054                img = img.convert('L')
1055                
1056            # 2. Optional: Apply some contrast enhancement
1057            # (Disabled by default, enable if needed for specific cases)
1058            # from PIL import ImageEnhance
1059            # enhancer = ImageEnhance.Contrast(img)
1060            # img = enhancer.enhance(1.5)  # Increase contrast
1061                
1062            # Perform OCR with custom configuration
1063            custom_config = r'--oem 3 --psm 6'  # Default OCR Engine Mode and Page Segmentation Mode
1064            txt = pytesseract.image_to_string(img, config=custom_config).strip()
1065            return normalize_text(txt) or ""
1066    except Exception as e:
1067        logger.error(f"Failed image OCR: {e}")
1068        return None

1126def text_from_any(
1127    file_path: str
1128) -> Optional[str]:
1129    """
1130    Handle unknown file types by reporting stats and metadata.
1131
1132    Args:
1133        file_path (str): Path to the file.
1134
1135    Returns:
1136        Optional[str]: Plain-text report, or None on error.
1137    """
1138    content = ""
1139    path = clean_path(file_path)
1140    if not path:
1141        return None
1142    try:
1143        stats = os.stat(path)
1144        info = {
1145            "path": path,
1146            "size": stats.st_size,
1147            "created": datetime.fromtimestamp(stats.st_ctime).isoformat(),
1148            "modified": datetime.fromtimestamp(stats.st_mtime).isoformat(),
1149        }
1150
1151        for k, v in info.items():
1152            content += "File System Data:\n"
1153            content += f"{k}: {v}\n"
1154        
1155        # Try to extract EXIF if available
1156        exif = extract_exif(path)
1157        if exif:
1158            info["exif"] = exif
1159            content += "\n\nEXIF Data:\n"
1160            for k, v in exif.items():
1161                if isinstance(v, dict):
1162                    content += f"\n{k}:\n"
1163                    for sub_k, sub_v in v.items():
1164                        content += f"  {sub_k}: {sub_v}\n"
1165                else:
1166                    content += f"{k}: {v}\n"
1167
1168        # Get file hash
1169        md5_hash = hashlib.md5(open(path,'rb').read()).hexdigest()
1170        info["md5"] = md5_hash
1171
1172        # Get strings
1173        strings = extract_strings(path)
1174        if strings:
1175            info["strings"] = strings
1176            content += "\n\nStrings Data:\n"
1177            clean_strings = "\n".join(strings)
1178            content += clean_strings
1179
1180        return info 
1181    except Exception as e:
1182        logger.error(f"Error on other file: {e}")
1183        return None

3123def text_from_odt(odt_path: str) -> Optional[str]:
3124    """
3125    Extract text from OpenDocument Text files.
3126    
3127    Args:
3128        odt_path (str): Path to the ODT file
3129        
3130    Returns:
3131        Optional[str]: Extracted text
3132    """
3133    try:
3134        from odf import text, teletype
3135        from odf.opendocument import load
3136        
3137        textdoc = load(odt_path)
3138        
3139        # Extract metadata
3140        meta = []
3141        meta_elem = textdoc.meta
3142        if meta_elem:
3143            for prop in meta_elem.childNodes:
3144                if hasattr(prop, 'tagName') and hasattr(prop, 'childNodes') and prop.childNodes:
3145                    meta.append(f"{prop.tagName}: {teletype.extractText(prop)}")
3146        
3147        # Extract content
3148        allparas = textdoc.getElementsByType(text.P)
3149        content = "\n".join(teletype.extractText(p) for p in allparas)
3150        
3151        # Combine metadata and content
3152        if meta:
3153            final_text = "\n".join(meta) + "\n---\n" + content
3154        else:
3155            final_text = content
3156        
3157        return normalize_text(final_text)
3158    except ImportError:
3159        logger.error("odfpy not installed")
3160        return "odfpy package is required for ODT processing"
3161    except Exception as e:
3162        logger.error(f"Error processing ODT: {e}")
3163        return None

3080def text_from_pptx(pptx_path: str) -> Optional[str]:
3081    """
3082    Extract text from PowerPoint presentations.
3083    
3084    Args:
3085        pptx_path (str): Path to the PowerPoint file
3086        
3087    Returns:
3088        Optional[str]: Extracted text
3089    """
3090    try:
3091        from pptx import Presentation
3092        
3093        prs = Presentation(pptx_path)
3094        text = ["--- PowerPoint Presentation ---"]
3095        
3096        for i, slide in enumerate(prs.slides, 1):
3097            slide_text = [f"Slide {i}:"]
3098            
3099            # Get slide title if it exists
3100            if slide.shapes.title and slide.shapes.title.text:
3101                slide_text.append(f"Title: {slide.shapes.title.text}")
3102            
3103            # Extract text from all shapes
3104            shape_text = []
3105            for shape in slide.shapes:
3106                if hasattr(shape, "text") and shape.text:
3107                    shape_text.append(shape.text)
3108            
3109            if shape_text:
3110                slide_text.append("\n".join(shape_text))
3111            
3112            text.append("\n".join(slide_text))
3113        
3114        return normalize_text("\n\n".join(text))
3115    except ImportError:
3116        logger.error("python-pptx not installed")
3117        return "python-pptx package is required for PowerPoint processing"
3118    except Exception as e:
3119        logger.error(f"Error processing PowerPoint: {e}")
3120        return None

3033def text_from_epub(epub_path: str) -> Optional[str]:
3034    """
3035    Extract text from EPUB ebooks.
3036    
3037    Args:
3038        epub_path (str): Path to the EPUB file
3039        
3040    Returns:
3041        Optional[str]: Extracted text
3042    """
3043    try:
3044        from ebooklib import epub
3045        import html2text
3046        
3047        book = epub.read_epub(epub_path)
3048        h = html2text.HTML2Text()
3049        h.ignore_links = False
3050        
3051        content = []
3052        
3053        # Get book metadata
3054        metadata = []
3055        if book.get_metadata('DC', 'title'):
3056            metadata.append(f"Title: {book.get_metadata('DC', 'title')[0][0]}")
3057        if book.get_metadata('DC', 'creator'):
3058            metadata.append(f"Author: {book.get_metadata('DC', 'creator')[0][0]}")
3059        if book.get_metadata('DC', 'description'):
3060            metadata.append(f"Description: {book.get_metadata('DC', 'description')[0][0]}")
3061        
3062        if metadata:
3063            content.append("\n".join(metadata))
3064            content.append("---")
3065        
3066        # Get book content
3067        for item in book.get_items():
3068            if item.get_type() == epub.ITEM_DOCUMENT:
3069                content.append(h.handle(item.get_content().decode('utf-8')))
3070        
3071        return normalize_text("\n".join(content))
3072    except ImportError:
3073        logger.error("ebooklib and/or html2text not installed")
3074        return "ebooklib and/or html2text packages are required for EPUB processing"
3075    except Exception as e:
3076        logger.error(f"Error processing EPUB: {e}")
3077        return None