pyxtxt 0.3.4.2__tar.gz → 0.3.5__tar.gz

{pyxtxt-0.3.4.2/src/pyxtxt.egg-info → pyxtxt-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyxtxt
-Version: 0.3.4.2
+Version: 0.3.5
 Summary: A Python library for extracting text from different types of files (PDF, DOCX, PPTX, XLSX, ODT, ecc.).
 Author-email: Giuseppe Levi <giuseppe.levi@gmail.com>
 License: MIT License
@@ -287,6 +287,13 @@ text = xtxt("scanned_document.png")
 text = xtxt("screenshot.jpg")
 text = xtxt("invoice.tiff")
 
+# Extract EXIF metadata from photos (uses Pillow, already included)
+from pyxtxt import xtxt_exif
+
+exif_data = xtxt_exif("vacation_photo.jpg")
+print(exif_data)
+# Output: Camera make/model, GPS coordinates, shooting settings, datetime, etc.
+
 # AI-powered OCR with Ollama (install with: pip install pyxtxt[ocr-ollama])
 # Requires: ollama server running + gemma3:4b model
 from pyxtxt import (

{pyxtxt-0.3.4.2 → pyxtxt-0.3.5}/README.md

@@ -185,6 +185,13 @@ text = xtxt("scanned_document.png")
 text = xtxt("screenshot.jpg")
 text = xtxt("invoice.tiff")
 
+# Extract EXIF metadata from photos (uses Pillow, already included)
+from pyxtxt import xtxt_exif
+
+exif_data = xtxt_exif("vacation_photo.jpg")
+print(exif_data)
+# Output: Camera make/model, GPS coordinates, shooting settings, datetime, etc.
+
 # AI-powered OCR with Ollama (install with: pip install pyxtxt[ocr-ollama])
 # Requires: ollama server running + gemma3:4b model
 from pyxtxt import (

{pyxtxt-0.3.4.2 → pyxtxt-0.3.5}/pyproject.toml

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

pyxtxt-0.3.5/src/pyxtxt/__init__.py

@@ -0,0 +1,59 @@
+from .core import xtxt, extxt_available_formats, xtxt_from_url
+
+# Import EXIF functions if available
+try:
+    from .estrattori.exif import xtxt_image_exif
+    exif_available = True
+except ImportError:
+    exif_available = False
+
+# Import OCR-Ollama functions if available
+try:
+    from .estrattori.ocr_ollama import (
+        set_ollama_model, get_ollama_model, xtxt_image_describe,
+        set_ollama_config, get_ollama_config, reset_ollama_config,
+        xtxt_image_with_confidence, configure_for_medical_images,
+        configure_for_xray_images, quick_xray_analysis
+    )
+    ollama_available = True
+except ImportError:
+    ollama_available = False
+
+# Build __all__ dynamically based on available features
+__all__ = ["xtxt", "extxt_available_formats", "xtxt_from_url"]
+
+if exif_available:
+    __all__.extend(["xtxt_exif"])
+
+if ollama_available:
+    __all__.extend([
+        "set_ollama_model", "get_ollama_model", "xtxt_image_describe",
+        "set_ollama_config", "get_ollama_config", "reset_ollama_config",
+        "xtxt_image_with_confidence", "configure_for_medical_images",
+        "configure_for_xray_images", "quick_xray_analysis"
+    ])
+
+# Define EXIF wrapper function
+def xtxt_exif(file_input):
+    """
+    Extract EXIF metadata from image files.
+    
+    Args:
+        file_input: Image file path (str) or file-like object
+        
+    Returns:
+        str: Formatted EXIF metadata or empty string if no EXIF data
+        
+    Example:
+        exif_data = xtxt_exif("photo.jpg")
+        print(exif_data)
+    """
+    if not exif_available:
+        raise ImportError("EXIF extraction requires Pillow. Install with: pip install pyxtxt[ocr]")
+    
+    # Handle file path
+    if isinstance(file_input, str):
+        with open(file_input, 'rb') as f:
+            return xtxt_image_exif(f)
+    else:
+        return xtxt_image_exif(file_input)

pyxtxt-0.3.5/src/pyxtxt/estrattori/exif.py

@@ -0,0 +1,183 @@
+# pyxtxt/extractors/image_exif.py
+from . import register_extractor
+from io import BytesIO
+import json
+
+try:
+    from PIL import Image, ExifTags
+    from PIL.ExifTags import TAGS, GPSTAGS
+except ImportError:
+    Image = None
+    ExifTags = None
+    TAGS = None
+    GPSTAGS = None
+
+if Image and ExifTags and TAGS:
+    def xtxt_image_exif(file_buffer):
+        """
+        Extract EXIF metadata from images as human-readable text.
+        
+        Returns formatted text with:
+        - Camera settings (make, model, lens, ISO, aperture, etc.)
+        - Shooting parameters (exposure, flash, focal length, etc.) 
+        - DateTime information (creation, modification dates)
+        - GPS coordinates (if available)
+        - Technical metadata (dimensions, orientation, color space, etc.)
+        """
+        try:
+            # Convert buffer to PIL Image
+            if hasattr(file_buffer, 'seek'):
+                file_buffer.seek(0)
+            image_data = file_buffer.read()
+            image = Image.open(BytesIO(image_data))
+            
+            # Get EXIF data
+            exif_data = image._getexif()
+            
+            if not exif_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
+                
+                # Format common values
+                if tag_name in ["DateTime", "DateTimeOriginal", "DateTimeDigitized"]:
+                    exif_text_lines.append(f"{tag_name}: {value}")
+                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")
+                    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")
+                        else:
+                            exif_text_lines.append(f"{tag_name}: {value}")
+                    else:
+                        exif_text_lines.append(f"{tag_name}: {value}")
+                elif tag_name == "ISOSpeedRatings":
+                    exif_text_lines.append(f"ISO: {value}")
+                elif tag_name == "Flash":
+                    flash_modes = {
+                        0: "No Flash",
+                        1: "Flash Fired",
+                        5: "Flash Fired, Return not detected",
+                        7: "Flash Fired, Return detected",
+                        9: "Flash Fired, Compulsory",
+                        13: "Flash Fired, Compulsory, Return not detected",
+                        15: "Flash Fired, Compulsory, Return detected",
+                        16: "No Flash, Compulsory",
+                        24: "No Flash, Auto",
+                        25: "Flash Fired, Auto",
+                        29: "Flash Fired, Auto, Return not detected",
+                        31: "Flash Fired, Auto, Return detected",
+                        32: "No Flash Available"
+                    }
+                    flash_desc = flash_modes.get(value, f"Flash Mode {value}")
+                    exif_text_lines.append(f"Flash: {flash_desc}")
+                elif tag_name in ["ExposureMode", "WhiteBalance", "SceneCaptureType", "MeteringMode"]:
+                    exif_text_lines.append(f"{tag_name}: {value}")
+                elif tag_name == "Orientation":
+                    orientations = {
+                        1: "Normal", 2: "Mirrored horizontal", 3: "Rotated 180°", 
+                        4: "Mirrored vertical", 5: "Mirrored horizontal + rotated 90° CCW",
+                        6: "Rotated 90° CW", 7: "Mirrored horizontal + rotated 90° CW",
+                        8: "Rotated 90° CCW"
+                    }
+                    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
+                    exif_text_lines.append(f"{tag_name}: {value}")
+            
+            # Process GPS data if available
+            if gps_data:
+                gps_text_lines = []
+                gps_info = {}
+                
+                # Extract GPS coordinates
+                for gps_tag_id, gps_value in gps_data.items():
+                    gps_tag_name = GPSTAGS.get(gps_tag_id, f"GPSTag_{gps_tag_id}")
+                    gps_info[gps_tag_name] = gps_value
+                
+                # Format coordinates if available
+                if 'GPSLatitude' in gps_info and 'GPSLatitudeRef' in gps_info:
+                    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
+                        if lat_ref == 'S':
+                            lat_deg = -lat_deg
+                        gps_text_lines.append(f"GPS Latitude: {lat_deg:.6f}° {lat_ref}")
+                
+                if 'GPSLongitude' in gps_info and 'GPSLongitudeRef' in gps_info:
+                    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
+                        if lon_ref == 'W':
+                            lon_deg = -lon_deg
+                        gps_text_lines.append(f"GPS Longitude: {lon_deg:.6f}° {lon_ref}")
+                
+                # Add other GPS info
+                for tag_name, value in gps_info.items():
+                    if tag_name not in ['GPSLatitude', 'GPSLatitudeRef', 'GPSLongitude', 'GPSLongitudeRef']:
+                        if isinstance(value, (str, int, float)):
+                            gps_text_lines.append(f"{tag_name}: {value}")
+                
+                if gps_text_lines:
+                    exif_text_lines.extend(["", "=== GPS Information ==="] + gps_text_lines)
+            
+            # Add image basic info
+            basic_info = [
+                "",
+                "=== Image Information ===",
+                f"Format: {image.format}",
+                f"Mode: {image.mode}",
+                f"Size: {image.width} x {image.height} pixels"
+            ]
+            
+            # Return formatted EXIF data
+            if exif_text_lines:
+                result = "=== EXIF Metadata ===" + "\n" + "\n".join(exif_text_lines) + "\n" + "\n".join(basic_info)
+                return result
+            else:
+                return "NO_READABLE_EXIF_DATA"
+            
+        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")

{pyxtxt-0.3.4.2 → pyxtxt-0.3.5/src/pyxtxt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyxtxt
-Version: 0.3.4.2
+Version: 0.3.5
 Summary: A Python library for extracting text from different types of files (PDF, DOCX, PPTX, XLSX, ODT, ecc.).
 Author-email: Giuseppe Levi <giuseppe.levi@gmail.com>
 License: MIT License
@@ -287,6 +287,13 @@ text = xtxt("scanned_document.png")
 text = xtxt("screenshot.jpg")
 text = xtxt("invoice.tiff")
 
+# Extract EXIF metadata from photos (uses Pillow, already included)
+from pyxtxt import xtxt_exif
+
+exif_data = xtxt_exif("vacation_photo.jpg")
+print(exif_data)
+# Output: Camera make/model, GPS coordinates, shooting settings, datetime, etc.
+
 # AI-powered OCR with Ollama (install with: pip install pyxtxt[ocr-ollama])
 # Requires: ollama server running + gemma3:4b model
 from pyxtxt import (

{pyxtxt-0.3.4.2 → pyxtxt-0.3.5}/src/pyxtxt.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ src/pyxtxt/estrattori/doc.py
 src/pyxtxt/estrattori/docx.py
 src/pyxtxt/estrattori/eml.py
 src/pyxtxt/estrattori/epub.py
+src/pyxtxt/estrattori/exif.py
 src/pyxtxt/estrattori/html.py
 src/pyxtxt/estrattori/md.py
 src/pyxtxt/estrattori/msg.py

pyxtxt-0.3.4.2/src/pyxtxt/__init__.py

@@ -1,19 +0,0 @@
-from .core import xtxt, extxt_available_formats, xtxt_from_url
-
-# Import OCR-Ollama functions if available
-try:
-    from .estrattori.ocr_ollama import (
-        set_ollama_model, get_ollama_model, xtxt_image_describe,
-        set_ollama_config, get_ollama_config, reset_ollama_config,
-        xtxt_image_with_confidence, configure_for_medical_images,
-        configure_for_xray_images, quick_xray_analysis
-    )
-    __all__ = [
-        "xtxt", "extxt_available_formats", "xtxt_from_url", 
-        "set_ollama_model", "get_ollama_model", "xtxt_image_describe",
-        "set_ollama_config", "get_ollama_config", "reset_ollama_config",
-        "xtxt_image_with_confidence", "configure_for_medical_images",
-        "configure_for_xray_images", "quick_xray_analysis"
-    ]
-except ImportError:
-    __all__ = ["xtxt", "extxt_available_formats", "xtxt_from_url"]