pyxtxt 0.3.7__tar.gz → 0.3.8__tar.gz

{pyxtxt-0.3.7/src/pyxtxt.egg-info → pyxtxt-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyxtxt
-Version: 0.3.7
+Version: 0.3.8
 Summary: A Python library for extracting text from different types of files (PDF, DOCX, PPTX, XLSX, ODT, etc.).
 Author-email: Giuseppe Levi <giuseppe.levi@gmail.com>
 License-Expression: MIT
@@ -102,7 +102,7 @@ text = xtxt("report.pdf")
 
 ## ✨ Features
 
-- **One function for everything**: `xtxt()` accepts a file path, an `io.BytesIO` buffer, raw `bytes` or a `requests.Response`
+- **One function for everything**: `xtxt()` accepts a file path, a binary file object, an `io.BytesIO` buffer, raw `bytes` or a `requests.Response`
 - **Automatic type detection** with `python-magic`, refined by the file extension when libmagic is not specific enough (e.g. Markdown)
 - **Modular dependencies**: each format is an optional extra, the core only needs `python-magic`
 - **Office, web and document formats**: PDF, DOCX, PPTX, XLSX, XLS, ODT, HTML, XML, SVG, Markdown, EPUB, RTF, EML, MSG, LaTeX, DOC, TXT
@@ -117,8 +117,8 @@ text = xtxt("report.pdf")
 | Format | Install extra | Notes |
 |---|---|---|
 | PDF | `pdf` | PyMuPDF |
-| DOCX | `docx` | Paragraph text (tables are not extracted yet) |
-| PPTX | `presentation` | Text of all slide shapes |
+| DOCX | `docx` | Paragraphs and tables in document order, headers and footers |
+| PPTX | `presentation` | Text boxes, grouped shapes, tables and speaker notes |
 | XLSX, XLS | `spreadsheet` | Every row of every visible sheet, cells joined with ` \| ` |
 | ODT | `odf` | |
 | HTML | `html` | |
@@ -127,11 +127,11 @@ text = xtxt("report.pdf")
 | EPUB | `epub` | |
 | RTF | `rtf` | |
 | EML | `email` | Plain-text and HTML parts |
-| MSG (Outlook) | `outlook` | |
+| MSG (Outlook) | `outlook` | Plain-text body, or the HTML body when there is no plain text |
 | LaTeX | `latex` | |
 | DOC (legacy Word) | — | Needs the `antiword` system tool |
 | TXT and other `text/*` | — | Always available, decoded as UTF-8 |
-| Audio and video | `audio` | Whisper, needs `ffmpeg`; heavy download |
+| Audio and video | `audio` | Whisper, needs `ffmpeg`; heavy download. MP3, WAV, M4A, AAC, FLAC, OGG/Opus, AIFF, WMA, MP4, MOV, AVI, MKV, WebM |
 | Images (OCR) | `ocr` or `ocr-ollama` | See [OCR from images](#-ocr-from-images) |
 
 To list what is available in your installation:
@@ -208,9 +208,12 @@ from pyxtxt import xtxt
 # From a file path
 text = xtxt("document.pdf")
 
-# From an in-memory buffer
+# From a file object opened in binary mode
 with open("document.docx", "rb") as f:
-    buffer = io.BytesIO(f.read())
+    text = xtxt(f)
+
+# From an in-memory buffer
+buffer = io.BytesIO(docx_bytes)
 text = xtxt(buffer)
 
 # Give the buffer a name to help type detection (useful for Markdown, LaTeX, RTF)
@@ -344,12 +347,12 @@ print((files("pyxtxt") / "examples.py").read_text())
 
 ## ⚠️ Known limitations
 
-- **Supported inputs**: file paths, `io.BytesIO`, `bytes` and `requests.Response`. A file object returned by
-  `open()` must be read first (`xtxt(f.read())`).
+- **Supported inputs**: file paths, binary file objects, `io.BytesIO`, `bytes` and `requests.Response`.
+  File objects opened in text mode are rejected: open them with `"rb"`.
 - **Type detection without a file name**: libmagic cannot tell apart some formats from raw bytes (legacy Office files
   share the same signature; Markdown looks like plain text). Pass a file path, or set `buffer.name`, when possible.
 - **Legacy PowerPoint (`.ppt`)** is not supported.
-- **DOCX**: text inside tables, headers and footers is not extracted yet. **SVG**: text inside `<tspan>` elements is not extracted yet.
+- **DOCX**: text boxes, footnotes and comments are not extracted. **PPTX**: text inside charts is not extracted.
 - Errors are reported with messages printed to standard output and the functions return `None` or an empty string;
   they do not raise exceptions.
 
@@ -407,6 +410,23 @@ Pull requests, issues and feedback are welcome.
 
 ## 📊 Changelog
 
+### v0.3.8
+- **NEW**: `xtxt()` accepts binary file objects, e.g. `xtxt(open("file.pdf", "rb"))`
+- **FIXED**: XLSX passed as `bytes` or `BytesIO` was detected as a ZIP archive and rejected
+- **FIXED**: WAV, M4A, AAC, AIFF, WMA and MKV files were never transcribed (libmagic reports them as `audio/x-wav`,
+  `audio/x-m4a`, `video/x-matroska`, ... which were not registered)
+- **FIXED**: MSG extraction always failed (`extract_msg.Message` has no `extract()` method)
+- **FIXED**: SVG extraction failed on `<text>` elements containing `<tspan>`
+- **IMPROVED**: DOCX now includes tables (in document order), headers and footers
+- **IMPROVED**: PPTX now includes grouped shapes, tables and speaker notes
+- **IMPROVED**: ODT now includes headings and text inside spans, links and lists
+- **IMPROVED**: EXIF output formats aperture, shutter speed and focal length as intended and reads PNG/WebP metadata
+  through Pillow's public API; the fake `image/*+exif` MIME types are gone from `extxt_available_formats()`
+- **IMPROVED**: Whisper temporary files are always deleted, also when transcription fails
+- **IMPROVED**: Ollama OCR stops trying fallback models when the server is not reachable;
+  `xtxt_image_with_confidence()` now uses the same context-aware prompts as `xtxt()`;
+  hallucination keywords match whole words (e.g. "roman" no longer fires on "romance")
+
 ### v0.3.7
 - Python 3.10 or newer is now required; metadata no longer lists the end-of-life versions 3.7–3.9, which were never tested
 - Python 3.14 is tested in CI and declared as supported

{pyxtxt-0.3.7 → pyxtxt-0.3.8}/README.md

@@ -19,7 +19,7 @@ text = xtxt("report.pdf")
 
 ## ✨ Features
 
-- **One function for everything**: `xtxt()` accepts a file path, an `io.BytesIO` buffer, raw `bytes` or a `requests.Response`
+- **One function for everything**: `xtxt()` accepts a file path, a binary file object, an `io.BytesIO` buffer, raw `bytes` or a `requests.Response`
 - **Automatic type detection** with `python-magic`, refined by the file extension when libmagic is not specific enough (e.g. Markdown)
 - **Modular dependencies**: each format is an optional extra, the core only needs `python-magic`
 - **Office, web and document formats**: PDF, DOCX, PPTX, XLSX, XLS, ODT, HTML, XML, SVG, Markdown, EPUB, RTF, EML, MSG, LaTeX, DOC, TXT
@@ -34,8 +34,8 @@ text = xtxt("report.pdf")
 | Format | Install extra | Notes |
 |---|---|---|
 | PDF | `pdf` | PyMuPDF |
-| DOCX | `docx` | Paragraph text (tables are not extracted yet) |
-| PPTX | `presentation` | Text of all slide shapes |
+| DOCX | `docx` | Paragraphs and tables in document order, headers and footers |
+| PPTX | `presentation` | Text boxes, grouped shapes, tables and speaker notes |
 | XLSX, XLS | `spreadsheet` | Every row of every visible sheet, cells joined with ` \| ` |
 | ODT | `odf` | |
 | HTML | `html` | |
@@ -44,11 +44,11 @@ text = xtxt("report.pdf")
 | EPUB | `epub` | |
 | RTF | `rtf` | |
 | EML | `email` | Plain-text and HTML parts |
-| MSG (Outlook) | `outlook` | |
+| MSG (Outlook) | `outlook` | Plain-text body, or the HTML body when there is no plain text |
 | LaTeX | `latex` | |
 | DOC (legacy Word) | — | Needs the `antiword` system tool |
 | TXT and other `text/*` | — | Always available, decoded as UTF-8 |
-| Audio and video | `audio` | Whisper, needs `ffmpeg`; heavy download |
+| Audio and video | `audio` | Whisper, needs `ffmpeg`; heavy download. MP3, WAV, M4A, AAC, FLAC, OGG/Opus, AIFF, WMA, MP4, MOV, AVI, MKV, WebM |
 | Images (OCR) | `ocr` or `ocr-ollama` | See [OCR from images](#-ocr-from-images) |
 
 To list what is available in your installation:
@@ -125,9 +125,12 @@ from pyxtxt import xtxt
 # From a file path
 text = xtxt("document.pdf")
 
-# From an in-memory buffer
+# From a file object opened in binary mode
 with open("document.docx", "rb") as f:
-    buffer = io.BytesIO(f.read())
+    text = xtxt(f)
+
+# From an in-memory buffer
+buffer = io.BytesIO(docx_bytes)
 text = xtxt(buffer)
 
 # Give the buffer a name to help type detection (useful for Markdown, LaTeX, RTF)
@@ -261,12 +264,12 @@ print((files("pyxtxt") / "examples.py").read_text())
 
 ## ⚠️ Known limitations
 
-- **Supported inputs**: file paths, `io.BytesIO`, `bytes` and `requests.Response`. A file object returned by
-  `open()` must be read first (`xtxt(f.read())`).
+- **Supported inputs**: file paths, binary file objects, `io.BytesIO`, `bytes` and `requests.Response`.
+  File objects opened in text mode are rejected: open them with `"rb"`.
 - **Type detection without a file name**: libmagic cannot tell apart some formats from raw bytes (legacy Office files
   share the same signature; Markdown looks like plain text). Pass a file path, or set `buffer.name`, when possible.
 - **Legacy PowerPoint (`.ppt`)** is not supported.
-- **DOCX**: text inside tables, headers and footers is not extracted yet. **SVG**: text inside `<tspan>` elements is not extracted yet.
+- **DOCX**: text boxes, footnotes and comments are not extracted. **PPTX**: text inside charts is not extracted.
 - Errors are reported with messages printed to standard output and the functions return `None` or an empty string;
   they do not raise exceptions.
 
@@ -324,6 +327,23 @@ Pull requests, issues and feedback are welcome.
 
 ## 📊 Changelog
 
+### v0.3.8
+- **NEW**: `xtxt()` accepts binary file objects, e.g. `xtxt(open("file.pdf", "rb"))`
+- **FIXED**: XLSX passed as `bytes` or `BytesIO` was detected as a ZIP archive and rejected
+- **FIXED**: WAV, M4A, AAC, AIFF, WMA and MKV files were never transcribed (libmagic reports them as `audio/x-wav`,
+  `audio/x-m4a`, `video/x-matroska`, ... which were not registered)
+- **FIXED**: MSG extraction always failed (`extract_msg.Message` has no `extract()` method)
+- **FIXED**: SVG extraction failed on `<text>` elements containing `<tspan>`
+- **IMPROVED**: DOCX now includes tables (in document order), headers and footers
+- **IMPROVED**: PPTX now includes grouped shapes, tables and speaker notes
+- **IMPROVED**: ODT now includes headings and text inside spans, links and lists
+- **IMPROVED**: EXIF output formats aperture, shutter speed and focal length as intended and reads PNG/WebP metadata
+  through Pillow's public API; the fake `image/*+exif` MIME types are gone from `extxt_available_formats()`
+- **IMPROVED**: Whisper temporary files are always deleted, also when transcription fails
+- **IMPROVED**: Ollama OCR stops trying fallback models when the server is not reachable;
+  `xtxt_image_with_confidence()` now uses the same context-aware prompts as `xtxt()`;
+  hallucination keywords match whole words (e.g. "roman" no longer fires on "romance")
+
 ### v0.3.7
 - Python 3.10 or newer is now required; metadata no longer lists the end-of-life versions 3.7–3.9, which were never tested
 - Python 3.14 is tested in CI and declared as supported

{pyxtxt-0.3.7 → pyxtxt-0.3.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pyxtxt"
-version = "0.3.7"
+version = "0.3.8"
 description = "A Python library for extracting text from different types of files (PDF, DOCX, PPTX, XLSX, ODT, etc.)."
 classifiers = [
   "Development Status :: 4 - Beta",

{pyxtxt-0.3.7 → pyxtxt-0.3.8}/src/pyxtxt/core.py

@@ -17,6 +17,15 @@ _TEXT_EXTENSION_HINTS = {
 }
 
 
+def _detect_mime_type(data: bytes) -> str:
+    """Detect the MIME type of in-memory data.
+
+    The whole buffer is passed to libmagic: the first few KB are not always
+    enough to tell apart ZIP-based formats (e.g. XLSX is seen as application/zip).
+    """
+    return magic.from_buffer(data, mime=True)
+
+
 def _resolve_mime_type(mime_type: str, name: Optional[str]) -> str:
     """Refine the detected MIME type and map unknown text types to text/plain."""
     if mime_type == "text/plain" and name:
@@ -45,7 +54,7 @@ def _(file_input: str) -> Optional[str]:
             data = f.read()
         buffer = io.BytesIO(data)
         buffer.name = file_input
-        buffer.mimeType = magic.Magic(mime=True).from_file(file_input)
+        buffer.mimeType = magic.from_file(file_input, mime=True)
         return xtxt(buffer)
     except Exception as e:
         print(f"⚠️ File opening error '{file_input}': {e}")
@@ -59,8 +68,7 @@ def _(file_input: io.BytesIO) -> Optional[str]:
         if hasattr(file_input, "mimeType"):
             mime_type = file_input.mimeType
         else:
-            file_input.seek(0)
-            mime_type = magic.Magic(mime=True).from_buffer(file_input.read(2048))
+            mime_type = _detect_mime_type(file_input.getvalue())
             file_input.seek(0)
         if not getattr(file_input, "name", None):
             file_input.name = "IO_buffer"
@@ -83,13 +91,31 @@ def _(file_input: bytes) -> Optional[str]:
     try:
         buffer = io.BytesIO(file_input)
         buffer.name = "bytes_input"
-        buffer.mimeType = magic.Magic(mime=True).from_buffer(file_input[:2048])
+        buffer.mimeType = _detect_mime_type(file_input)
         return xtxt(buffer)
     except Exception as e:
         print(f"❌ Error processing bytes: {e}")
         return None
 
 
+@xtxt.register
+def _(file_input: io.IOBase) -> Optional[str]:
+    """Extract text from a binary file object, e.g. one returned by open(path, "rb")."""
+    try:
+        data = file_input.read()
+        if isinstance(data, str):
+            print("⚠️ File object opened in text mode: open it in binary mode ('rb')")
+            return None
+        buffer = io.BytesIO(data)
+        name = getattr(file_input, "name", None)
+        buffer.name = name if isinstance(name, str) else "file_object"
+        buffer.mimeType = _detect_mime_type(data)
+        return xtxt(buffer)
+    except Exception as e:
+        print(f"❌ Error processing file object: {e}")
+        return None
+
+
 # Optional support for requests.Response
 try:
     import requests

{pyxtxt-0.3.7 → pyxtxt-0.3.8}/src/pyxtxt/estrattori/audio.py

@@ -10,69 +10,66 @@ except ImportError:
 
 if whisper:
     _whisper_model = None
-    
+
     def _get_model():
         global _whisper_model
         if _whisper_model is None:
             _whisper_model = whisper.load_model("base")
         return _whisper_model
-    
+
     def xtxt_audio_whisper(file_buffer):
+        temp_path = None
         try:
-            # Usa un suffixe generico - Whisper + FFmpeg gestiscono il formato
+            # Usa un suffisso generico - Whisper + FFmpeg gestiscono il formato
             with tempfile.NamedTemporaryFile(delete=False) as temp_file:
                 temp_file.write(file_buffer.read())
-                temp_file.flush()
-                
-                model = _get_model()
-                result = model.transcribe(
-                temp_file.name,
+                temp_path = temp_file.name
+
+            model = _get_model()
+            result = model.transcribe(
+                temp_path,
                 language=None,
                 task="transcribe",
                 temperature=[0.0, 0.2, 0.4, 0.6, 0.8, 1.0],
-                word_timestamps=True
-                )
-                
-                os.unlink(temp_file.name)
-                text_with_languages = []
-                current_lang = None
-            
-                for segment in result['segments']:
-                # Rileva cambio di lingua (logica semplificata)
-                    if 'language' in segment and segment['language'] != current_lang:
-                        current_lang = segment['language']
-                        text_with_languages.append(f"\n[{current_lang.upper()}]")
-                
-                    text_with_languages.append(segment['text'])
-            
-                return " ".join(text_with_languages).strip()
-                
+            )
+            return result["text"].strip()
+
         except Exception as e:
             print(f"⚠️ Error while extracting audio with Whisper: {e}")
             return ""
-    
-    # Registra per tutti i formati audio comuni
+        finally:
+            if temp_path is not None:
+                os.unlink(temp_path)
+
+    # Registra per tutti i formati audio comuni.
+    # Comprende sia i nomi standard sia quelli restituiti da libmagic (es. audio/x-wav).
     audio_formats = [
-        "audio/wav", "audio/wave",
+        "audio/wav", "audio/wave", "audio/x-wav",
         "audio/mp3", "audio/mpeg",
-        "audio/m4a", "audio/mp4",
-        "audio/flac",
+        "audio/m4a", "audio/x-m4a", "audio/mp4",
+        "audio/flac", "audio/x-flac",
         "audio/ogg", "audio/ogg-vorbis",
         "audio/opus",
-        "audio/aac",
-        "audio/wma",
-        "audio/webm"
+        "audio/aac", "audio/x-hx-aac-adts",
+        "audio/aiff", "audio/x-aiff",
+        "audio/wma", "audio/x-ms-wma",
+        "audio/webm",
     ]
-    
+
     for format_type in audio_formats:
         register_extractor(format_type, xtxt_audio_whisper, name="Whisper Audio")
-# Aggiungi questi formati video al tuo registro
+
+    # Formati video: Whisper estrae la traccia audio tramite FFmpeg
     video_audio_formats = [
-        "video/mp4",
+        "video/mp4", "video/x-m4v",
         "video/quicktime",  # .mov
         "video/x-msvideo",  # .avi
         "video/webm",
-        "video/mkv"
+        "video/mkv", "video/x-matroska",
+        "video/x-ms-asf",  # .wmv / .wma
+        "video/mpeg",
+        "video/ogg",
+        "video/3gpp",
     ]
 
     for format_type in video_audio_formats:

pyxtxt-0.3.8/src/pyxtxt/estrattori/docx.py

@@ -0,0 +1,75 @@
+from . import register_extractor
+import io
+import zipfile
+try:
+    from docx import Document
+    from docx.oxml.ns import qn
+    from docx.table import Table
+    from docx.text.paragraph import Paragraph
+except ImportError:
+    Document = None
+
+if Document:
+    def _block_lines(parent, element):
+        """Yield the text of paragraphs and tables in document order."""
+        for child in element.iterchildren():
+            if child.tag == qn("w:p"):
+                yield Paragraph(child, parent).text
+            elif child.tag == qn("w:tbl"):
+                yield from _table_lines(Table(child, parent))
+
+    def _table_lines(table):
+        """Yield one line per table row, cells separated by ' | '."""
+        for row in table.rows:
+            seen = []
+            cells = []
+            for cell in row.cells:
+                # Merged cells are returned once per grid column: keep the first one
+                if any(cell._tc is tc for tc in seen):
+                    continue
+                seen.append(cell._tc)
+                cell_text = " ".join(line for line in _block_lines(cell, cell._tc) if line)
+                cells.append(cell_text.strip())
+            if any(cells):
+                yield " | ".join(cells)
+
+    def _header_footer_lines(doc, attribute_names):
+        lines = []
+        for section in doc.sections:
+            for attribute in attribute_names:
+                part = getattr(section, attribute, None)
+                if part is None or part.is_linked_to_previous:
+                    continue
+                for line in _block_lines(part, part._element):
+                    if line and line not in lines:
+                        lines.append(line)
+        return lines
+
+    def xtxt_docx(file_buffer) -> str:
+        try:
+            # Copia del buffer per poterlo riutilizzare
+            file_buffer.seek(0)
+            data = file_buffer.read()
+            buffer_copy = io.BytesIO(data)
+
+            if not zipfile.is_zipfile(buffer_copy):
+                print("⚠️ Invalid DOCX (not a ZIP file)")
+                return ""
+
+            buffer_copy.seek(0)
+            doc = Document(buffer_copy)
+
+            headers = _header_footer_lines(doc, ("first_page_header", "header", "even_page_header"))
+            body = list(_block_lines(doc, doc.element.body))
+            footers = _header_footer_lines(doc, ("first_page_footer", "footer", "even_page_footer"))
+            return "\n".join(headers + body + footers)
+
+        except Exception as e:
+            print(f"⚠️  Error during extraction DOCX: {e}")
+            return ""
+
+    register_extractor(
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        xtxt_docx,
+        name="DOCX"
+    )

{pyxtxt-0.3.7 → pyxtxt-0.3.8}/src/pyxtxt/estrattori/exif.py

@@ -1,7 +1,6 @@
 # pyxtxt/extractors/image_exif.py
-from . import register_extractor
 from io import BytesIO
-import json
+import numbers
 
 try:
     from PIL import Image, ExifTags
@@ -13,6 +12,27 @@ except ImportError:
     GPSTAGS = None
 
 if Image and ExifTags and TAGS:
+    _EXIF_IFD = 0x8769  # ExifOffset: pointer to camera settings (FNumber, ExposureTime, ...)
+    _GPS_IFD = 0x8825   # GPSInfo: pointer to GPS data
+
+    def _as_ratio(value):
+        """Return (numerator, denominator) for EXIF rationals, or None.
+
+        Older Pillow versions return tuples, newer ones IFDRational objects.
+        """
+        if isinstance(value, tuple) and len(value) == 2:
+            return value
+        if isinstance(value, numbers.Rational) or hasattr(value, "denominator"):
+            return value.numerator, value.denominator
+        return None
+
+    def _collect_exif(image):
+        """Return (tags, gps) dictionaries keyed by numeric tag id."""
+        exif = image.getexif()
+        tags = {tag_id: value for tag_id, value in exif.items() if tag_id not in (_EXIF_IFD, _GPS_IFD)}
+        tags.update(exif.get_ifd(_EXIF_IFD))
+        return tags, dict(exif.get_ifd(_GPS_IFD))
+
     def xtxt_image_exif(file_buffer):
         """
         Extract EXIF metadata from images as human-readable text.
@@ -32,23 +52,19 @@ if Image and ExifTags and TAGS:
             image = Image.open(BytesIO(image_data))
             
             # Get EXIF data
-            exif_data = image._getexif()
+            exif_data, gps_data = _collect_exif(image)
             
-            if not exif_data:
+            if not exif_data and not gps_data:
                 return "NO_EXIF_DATA_FOUND"
             
             # Extract readable EXIF information
             exif_text_lines = []
-            gps_data = {}
             
             # Process main EXIF tags
             for tag_id, value in exif_data.items():
                 tag_name = TAGS.get(tag_id, f"UnknownTag_{tag_id}")
-                
-                # Handle special GPS data
-                if tag_name == "GPSInfo" and isinstance(value, dict):
-                    gps_data = value
-                    continue
+                if isinstance(value, str):
+                    value = value.strip("\x00 ")
                 
                 # Format common values
                 if tag_name in ["DateTime", "DateTimeOriginal", "DateTimeDigitized"]:
@@ -56,28 +72,27 @@ if Image and ExifTags and TAGS:
                 elif tag_name in ["Make", "Model", "Software", "Artist", "Copyright"]:
                     exif_text_lines.append(f"{tag_name}: {value}")
                 elif tag_name in ["XResolution", "YResolution"]:
-                    if isinstance(value, tuple) and len(value) == 2:
-                        resolution = value[0] / value[1] if value[1] != 0 else value[0]
-                        exif_text_lines.append(f"{tag_name}: {resolution:.1f} dpi")
+                    ratio = _as_ratio(value)
+                    if ratio and ratio[1] != 0:
+                        exif_text_lines.append(f"{tag_name}: {ratio[0] / ratio[1]:.1f} dpi")
                     else:
                         exif_text_lines.append(f"{tag_name}: {value}")
                 elif tag_name in ["FNumber", "FocalLength", "ExposureTime"]:
-                    if isinstance(value, tuple) and len(value) == 2:
-                        if value[1] != 0:
-                            if tag_name == "FNumber":
-                                f_value = value[0] / value[1]
-                                exif_text_lines.append(f"Aperture: f/{f_value:.1f}")
-                            elif tag_name == "FocalLength":
-                                focal_mm = value[0] / value[1]
-                                exif_text_lines.append(f"Focal Length: {focal_mm:.0f}mm")
-                            elif tag_name == "ExposureTime":
-                                if value[0] == 1:
-                                    exif_text_lines.append(f"Shutter Speed: 1/{value[1]}s")
-                                else:
-                                    exp_time = value[0] / value[1]
-                                    exif_text_lines.append(f"Shutter Speed: {exp_time:.3f}s")
+                    ratio = _as_ratio(value)
+                    if ratio and ratio[1] != 0:
+                        numerator, denominator = ratio
+                        if tag_name == "FNumber":
+                            exif_text_lines.append(f"Aperture: f/{numerator / denominator:.1f}")
+                        elif tag_name == "FocalLength":
+                            exif_text_lines.append(f"Focal Length: {numerator / denominator:.0f}mm")
+                        elif numerator == 1:
+                            exif_text_lines.append(f"Shutter Speed: 1/{denominator}s")
                         else:
-                            exif_text_lines.append(f"{tag_name}: {value}")
+                            exp_time = numerator / denominator
+                            if exp_time < 1:
+                                exif_text_lines.append(f"Shutter Speed: 1/{round(1 / exp_time)}s")
+                            else:
+                                exif_text_lines.append(f"Shutter Speed: {exp_time:g}s")
                     else:
                         exif_text_lines.append(f"{tag_name}: {value}")
                 elif tag_name == "ISOSpeedRatings":
@@ -111,8 +126,10 @@ if Image and ExifTags and TAGS:
                     }
                     orient_desc = orientations.get(value, f"Orientation {value}")
                     exif_text_lines.append(f"Orientation: {orient_desc}")
-                elif isinstance(value, (str, int, float)):
-                    # Include other simple values
+                elif isinstance(value, (str, numbers.Number)):
+                    # Include other simple values (rationals as decimals)
+                    if not isinstance(value, (str, int)):
+                        value = round(float(value), 4)
                     exif_text_lines.append(f"{tag_name}: {value}")
             
             # Process GPS data if available
@@ -130,7 +147,7 @@ if Image and ExifTags and TAGS:
                     lat_dms = gps_info['GPSLatitude']
                     lat_ref = gps_info['GPSLatitudeRef']
                     if len(lat_dms) == 3:
-                        lat_deg = lat_dms[0] + lat_dms[1]/60 + lat_dms[2]/3600
+                        lat_deg = float(lat_dms[0]) + float(lat_dms[1])/60 + float(lat_dms[2])/3600
                         if lat_ref == 'S':
                             lat_deg = -lat_deg
                         gps_text_lines.append(f"GPS Latitude: {lat_deg:.6f}° {lat_ref}")
@@ -139,7 +156,7 @@ if Image and ExifTags and TAGS:
                     lon_dms = gps_info['GPSLongitude']
                     lon_ref = gps_info['GPSLongitudeRef']
                     if len(lon_dms) == 3:
-                        lon_deg = lon_dms[0] + lon_dms[1]/60 + lon_dms[2]/3600
+                        lon_deg = float(lon_dms[0]) + float(lon_dms[1])/60 + float(lon_dms[2])/3600
                         if lon_ref == 'W':
                             lon_deg = -lon_deg
                         gps_text_lines.append(f"GPS Longitude: {lon_deg:.6f}° {lon_ref}")
@@ -172,12 +189,5 @@ if Image and ExifTags and TAGS:
         except Exception as e:
             print(f"⚠️ Error extracting EXIF from image: {e}")
             return ""
-    
-    # Register EXIF extractor for image formats with dedicated MIME types
-    # Using EXIF-specific MIME types to avoid conflicts with OCR extractors
-    register_extractor("image/jpeg+exif", xtxt_image_exif, name="EXIF")
-    register_extractor("image/jpg+exif", xtxt_image_exif, name="EXIF") 
-    register_extractor("image/png+exif", xtxt_image_exif, name="EXIF")
-    register_extractor("image/tiff+exif", xtxt_image_exif, name="EXIF")
-    register_extractor("image/bmp+exif", xtxt_image_exif, name="EXIF")
-    register_extractor("image/webp+exif", xtxt_image_exif, name="EXIF")
+
+    # EXIF metadata is exposed through pyxtxt.xtxt_exif(): xtxt() on an image runs OCR.

pyxtxt-0.3.8/src/pyxtxt/estrattori/msg.py

@@ -0,0 +1,31 @@
+from . import register_extractor
+
+try:
+    import extract_msg
+    from bs4 import BeautifulSoup
+except ImportError:
+    extract_msg = None
+
+if extract_msg:
+    def xtxt_msg(file_buffer):
+        # extract_msg accetta direttamente i bytes del file .msg
+        content = file_buffer.read()
+
+        with extract_msg.openMsg(content) as msg:
+            body = getattr(msg, "body", None)
+            if body and body.strip():
+                return body.strip()
+
+            # Nessun corpo in testo semplice: usa la versione HTML
+            html_body = getattr(msg, "htmlBody", None)
+            if html_body:
+                soup = BeautifulSoup(html_body, "html.parser")
+                return soup.get_text(separator="\n").strip()
+
+            return ""
+
+    register_extractor(
+        "application/vnd.ms-outlook",
+        xtxt_msg,
+        name="MSG"
+    )