scitex 2.7.0__py3-none-any.whl → 2.7.3__py3-none-any.whl

scitex/io/_metadata_modules/_read.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/io/_metadata_modules/_read.py
+
+"""Main read_metadata dispatcher."""
+
+import os
+from typing import Any, Dict, Optional
+
+
+def read_metadata(image_path: str) -> Optional[Dict[str, Any]]:
+    """
+    Read metadata from an image or PDF file.
+
+    Args:
+        image_path: Path to the file (PNG, JPEG, SVG, or PDF)
+
+    Returns:
+        Dictionary containing metadata, or None if no metadata found
+
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        ValueError: If file format is not supported
+
+    Example:
+        >>> metadata = read_metadata('result.png')
+        >>> print(metadata['experiment'])
+        'seizure_prediction_001'
+        >>> metadata = read_metadata('result.pdf')
+    """
+    if not os.path.exists(image_path):
+        raise FileNotFoundError(f"File not found: {image_path}")
+
+    path_lower = image_path.lower()
+
+    # Dispatch to format-specific handlers
+    if path_lower.endswith(".png"):
+        from .read_metadata_png import read_metadata_png
+
+        return read_metadata_png(image_path)
+
+    elif path_lower.endswith((".jpg", ".jpeg")):
+        from .read_metadata_jpeg import read_metadata_jpeg
+
+        return read_metadata_jpeg(image_path)
+
+    elif path_lower.endswith(".svg"):
+        from .read_metadata_svg import read_metadata_svg
+
+        return read_metadata_svg(image_path)
+
+    elif path_lower.endswith(".pdf"):
+        from .read_metadata_pdf import read_metadata_pdf
+
+        return read_metadata_pdf(image_path)
+
+    else:
+        raise ValueError(
+            f"Unsupported file format: {image_path}. "
+            "Only PNG, JPEG, SVG, and PDF formats are supported."
+        )
+
+
+# EOF

scitex/io/_metadata_modules/_utils.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/io/_metadata/_utils.py
+
+"""Shared utilities for metadata handling."""
+
+import json
+from typing import Any, Dict
+
+
+def convert_for_json(obj: Any) -> Any:
+    """
+    Convert non-JSON-serializable objects to serializable format.
+
+    Handles FixedFloat objects from figure metadata by converting
+    them to regular floats.
+    """
+    # Handle FixedFloat (from _collect_figure_metadata)
+    if (
+        hasattr(obj, "value")
+        and hasattr(obj, "precision")
+        and hasattr(obj, "__class__")
+        and obj.__class__.__name__ == "FixedFloat"
+    ):
+        return obj.value
+
+    # Handle dict recursively
+    if isinstance(obj, dict):
+        return {key: convert_for_json(value) for key, value in obj.items()}
+
+    # Handle list recursively
+    if isinstance(obj, list):
+        return [convert_for_json(item) for item in obj]
+
+    # Handle tuple
+    if isinstance(obj, tuple):
+        return [convert_for_json(item) for item in obj]
+
+    # Handle numpy arrays
+    if hasattr(obj, "tolist"):
+        return obj.tolist()
+
+    # Default: return as-is
+    return obj
+
+
+def serialize_metadata(metadata: Dict[str, Any]) -> str:
+    """Serialize metadata to JSON string."""
+    metadata = convert_for_json(metadata)
+    try:
+        return json.dumps(metadata, ensure_ascii=False, indent=2)
+    except (TypeError, ValueError) as e:
+        raise ValueError(f"Metadata must be JSON serializable: {e}")
+
+
+def has_metadata(image_path: str) -> bool:
+    """
+    Check if an image file has embedded metadata.
+
+    Args:
+        image_path: Path to the image file
+
+    Returns:
+        True if metadata exists, False otherwise
+
+    Example:
+        >>> if has_metadata('result.png'):
+        ...     print(read_metadata('result.png'))
+    """
+    from ._read import read_metadata
+
+    try:
+        metadata = read_metadata(image_path)
+        return metadata is not None
+    except:
+        return False
+
+
+# EOF

scitex/io/_metadata_modules/embed_metadata_jpeg.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/io/_metadata/embed_metadata_jpeg.py
+
+"""JPEG metadata embedding using EXIF ImageDescription field."""
+
+from PIL import Image
+
+
+def embed_metadata_jpeg(image_path: str, metadata_json: str) -> None:
+    """
+    Embed metadata into a JPEG file using EXIF ImageDescription field.
+
+    Args:
+        image_path: Path to the JPEG file.
+        metadata_json: JSON string of metadata to embed.
+
+    Raises:
+        ImportError: If piexif is not installed.
+    """
+    try:
+        import piexif
+    except ImportError:
+        raise ImportError(
+            "piexif is required for JPEG metadata support. "
+            "Install with: pip install piexif"
+        )
+
+    img = Image.open(image_path)
+
+    # Convert to RGB if necessary (JPEG doesn't support RGBA)
+    if img.mode in ("RGBA", "LA", "P"):
+        rgb_img = Image.new("RGB", img.size, (255, 255, 255))
+        if img.mode == "P":
+            img = img.convert("RGBA")
+        if img.mode in ("RGBA", "LA"):
+            rgb_img.paste(img, mask=img.split()[-1])
+        else:
+            rgb_img.paste(img)
+        img = rgb_img
+
+    # Create EXIF dict with metadata in ImageDescription field
+    exif_dict = {
+        "0th": {piexif.ImageIFD.ImageDescription: metadata_json.encode("utf-8")},
+        "Exif": {},
+        "GPS": {},
+        "1st": {},
+    }
+
+    # Try to preserve existing EXIF data
+    try:
+        existing_exif = piexif.load(img.info.get("exif", b""))
+        # Merge with new metadata (prioritize new metadata)
+        for ifd in ["Exif", "GPS", "1st"]:
+            if ifd in existing_exif:
+                exif_dict[ifd].update(existing_exif[ifd])
+    except:
+        pass  # If existing EXIF is corrupted, just use new metadata
+
+    exif_bytes = piexif.dump(exif_dict)
+
+    # Save with EXIF metadata (quality=100 for maximum quality)
+    img.save(
+        image_path,
+        "JPEG",
+        quality=100,
+        subsampling=0,
+        optimize=False,
+        exif=exif_bytes,
+    )
+    img.close()
+
+
+# EOF

scitex/io/_metadata_modules/embed_metadata_pdf.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/io/_metadata_modules/embed_metadata_pdf.py
+
+"""PDF metadata embedding using PDF Info Dictionary."""
+
+
+def embed_metadata_pdf(image_path: str, metadata_json: str, metadata: dict) -> None:
+    """
+    Embed metadata into a PDF file using PDF Info Dictionary.
+
+    Args:
+        image_path: Path to the PDF file.
+        metadata_json: JSON string of metadata to embed.
+        metadata: Original metadata dict for extracting title/author.
+
+    Raises:
+        ImportError: If pypdf is not installed.
+    """
+    try:
+        from pypdf import PdfReader, PdfWriter
+    except ImportError:
+        raise ImportError(
+            "pypdf is required for PDF metadata support. "
+            "Install with: pip install pypdf"
+        )
+
+    # Read existing PDF
+    reader = PdfReader(image_path)
+    writer = PdfWriter()
+
+    # Copy all pages
+    for page in reader.pages:
+        writer.add_page(page)
+
+    # Prepare metadata for PDF Info Dictionary
+    pdf_metadata = {
+        "/Title": metadata.get("title", ""),
+        "/Author": metadata.get("author", ""),
+        "/Subject": metadata_json,  # Store full JSON in Subject field
+        "/Creator": "SciTeX",
+        "/Producer": "SciTeX",
+    }
+
+    # Add metadata
+    writer.add_metadata(pdf_metadata)
+
+    # Write back to file
+    with open(image_path, "wb") as output_file:
+        writer.write(output_file)
+
+
+# EOF

scitex/io/_metadata_modules/embed_metadata_png.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/io/_metadata/embed_metadata_png.py
+
+"""PNG metadata embedding using tEXt chunks."""
+
+from PIL import Image
+from PIL.PngImagePlugin import PngInfo
+
+
+def embed_metadata_png(image_path: str, metadata_json: str) -> None:
+    """
+    Embed metadata into a PNG file using tEXt chunks.
+
+    Args:
+        image_path: Path to the PNG file.
+        metadata_json: JSON string of metadata to embed.
+    """
+    img = Image.open(image_path)
+    pnginfo = PngInfo()
+    pnginfo.add_text("scitex_metadata", metadata_json)
+    img.save(image_path, "PNG", pnginfo=pnginfo)
+    img.close()
+
+
+# EOF

scitex/io/_metadata_modules/embed_metadata_svg.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/io/_metadata_modules/embed_metadata_svg.py
+
+"""SVG metadata embedding using <metadata> element."""
+
+import re
+
+
+def embed_metadata_svg(image_path: str, metadata_json: str) -> None:
+    """
+    Embed metadata into an SVG file using <metadata> element.
+
+    Args:
+        image_path: Path to the SVG file.
+        metadata_json: JSON string of metadata to embed.
+
+    Raises:
+        ValueError: If the SVG file is invalid.
+    """
+    with open(image_path, "r", encoding="utf-8") as f:
+        svg_content = f.read()
+
+    # Remove existing scitex metadata if present
+    svg_content = re.sub(
+        r'<metadata[^>]*id="scitex_metadata"[^>]*>.*?</metadata>',
+        "",
+        svg_content,
+        flags=re.DOTALL,
+    )
+
+    # Find the opening <svg> tag and insert metadata after it
+    svg_match = re.search(r"(<svg[^>]*>)", svg_content)
+    if svg_match:
+        svg_tag_end = svg_match.end()
+        # Create metadata element with scitex data
+        metadata_element = (
+            f'\n<metadata id="scitex_metadata">'
+            f"<scitex:data>{metadata_json}</scitex:data>"
+            f"</metadata>\n"
+        )
+        svg_content = (
+            svg_content[:svg_tag_end]
+            + metadata_element
+            + svg_content[svg_tag_end:]
+        )
+
+        # Ensure scitex namespace is declared in svg tag if not present
+        if "xmlns:scitex" not in svg_content:
+            svg_content = svg_content.replace(
+                "<svg",
+                '<svg xmlns:scitex="http://scitex.io/metadata"',
+                1,
+            )
+
+        with open(image_path, "w", encoding="utf-8") as f:
+            f.write(svg_content)
+    else:
+        raise ValueError(f"Invalid SVG file: {image_path}")
+
+
+# EOF

scitex/io/_metadata_modules/read_metadata_jpeg.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/io/_metadata_modules/read_metadata_jpeg.py
+
+"""JPEG metadata reading from EXIF ImageDescription field."""
+
+import json
+from typing import Any, Dict, Optional
+
+from PIL import Image
+
+
+def read_metadata_jpeg(image_path: str) -> Optional[Dict[str, Any]]:
+    """
+    Read metadata from a JPEG file.
+
+    Args:
+        image_path: Path to the JPEG file.
+
+    Returns:
+        Dictionary containing metadata, or None if no metadata found.
+    """
+    metadata = None
+    img = Image.open(image_path)
+    try:
+        try:
+            import piexif
+
+            # Load EXIF data
+            if "exif" in img.info:
+                exif_dict = piexif.load(img.info["exif"])
+
+                # Try to read ImageDescription field
+                if piexif.ImageIFD.ImageDescription in exif_dict.get("0th", {}):
+                    description = exif_dict["0th"][piexif.ImageIFD.ImageDescription]
+
+                    # Decode bytes to string
+                    if isinstance(description, bytes):
+                        description = description.decode("utf-8", errors="ignore")
+
+                    # Try to parse as JSON
+                    try:
+                        metadata = json.loads(description)
+                    except json.JSONDecodeError:
+                        # If not JSON, return as raw text
+                        metadata = {"raw": description}
+        except ImportError:
+            pass  # piexif not available, return None
+        except Exception:
+            pass  # EXIF data corrupted or not readable
+    finally:
+        img.close()
+
+    return metadata
+
+
+# EOF

scitex/io/_metadata_modules/read_metadata_pdf.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/io/_metadata_modules/read_metadata_pdf.py
+
+"""PDF metadata reading from PDF Info Dictionary."""
+
+import json
+from typing import Any, Dict, Optional
+
+
+def read_metadata_pdf(image_path: str) -> Optional[Dict[str, Any]]:
+    """
+    Read metadata from a PDF file.
+
+    Args:
+        image_path: Path to the PDF file.
+
+    Returns:
+        Dictionary containing metadata, or None if no metadata found.
+    """
+    metadata = None
+
+    try:
+        from pypdf import PdfReader
+
+        reader = PdfReader(image_path)
+
+        # Try to read metadata from PDF Info Dictionary
+        if reader.metadata:
+            # Check Subject field for JSON metadata
+            if "/Subject" in reader.metadata:
+                subject = reader.metadata["/Subject"]
+                try:
+                    metadata = json.loads(subject)
+                except json.JSONDecodeError:
+                    # If not JSON, create metadata dict from available fields
+                    metadata = {
+                        "title": reader.metadata.get("/Title", ""),
+                        "author": reader.metadata.get("/Author", ""),
+                        "subject": subject,
+                        "creator": reader.metadata.get("/Creator", ""),
+                    }
+    except ImportError:
+        pass  # pypdf not available, return None
+    except Exception:
+        pass  # PDF metadata corrupted or not readable
+
+    return metadata
+
+
+# EOF

scitex/io/_metadata_modules/read_metadata_png.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/io/_metadata_modules/read_metadata_png.py
+
+"""PNG metadata reading from tEXt chunks."""
+
+import json
+from typing import Any, Dict, Optional
+
+from PIL import Image
+
+
+def read_metadata_png(image_path: str) -> Optional[Dict[str, Any]]:
+    """
+    Read metadata from a PNG file.
+
+    Args:
+        image_path: Path to the PNG file.
+
+    Returns:
+        Dictionary containing metadata, or None if no metadata found.
+    """
+    metadata = None
+    img = Image.open(image_path)
+    try:
+        if hasattr(img, "info") and "scitex_metadata" in img.info:
+            metadata_json = img.info["scitex_metadata"]
+            try:
+                metadata = json.loads(metadata_json)
+            except json.JSONDecodeError:
+                # Metadata exists but is not valid JSON
+                metadata = {"raw": metadata_json}
+    finally:
+        img.close()
+
+    return metadata
+
+
+# EOF

scitex/io/_metadata_modules/read_metadata_svg.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/io/_metadata_modules/read_metadata_svg.py
+
+"""SVG metadata reading from <metadata> element."""
+
+import json
+import re
+from typing import Any, Dict, Optional
+
+
+def read_metadata_svg(image_path: str) -> Optional[Dict[str, Any]]:
+    """
+    Read metadata from an SVG file.
+
+    Args:
+        image_path: Path to the SVG file.
+
+    Returns:
+        Dictionary containing metadata, or None if no metadata found.
+    """
+    metadata = None
+
+    with open(image_path, "r", encoding="utf-8") as f:
+        svg_content = f.read()
+
+    # Look for scitex metadata element
+    match = re.search(
+        r'<metadata[^>]*id="scitex_metadata"[^>]*>.*?'
+        r"<scitex:data>(.*?)</scitex:data>.*?</metadata>",
+        svg_content,
+        flags=re.DOTALL,
+    )
+    if match:
+        metadata_json = match.group(1)
+        try:
+            metadata = json.loads(metadata_json)
+        except json.JSONDecodeError:
+            metadata = {"raw": metadata_json}
+
+    return metadata
+
+
+# EOF

scitex/io/_qr_utils.py

@@ -9,9 +9,13 @@ import json
 import os
 from pathlib import Path
 
+from scitex import logging
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 
+logger = logging.getLogger(__name__)
+
 
 def add_qr_to_figure(fig, metadata, position="bottom-right", size=0.08):
     """
@@ -30,9 +34,7 @@ def add_qr_to_figure(fig, metadata, position="bottom-right", size=0.08):
         import qrcode
         from PIL import Image as PILImage
     except ImportError:
-        import warnings
-
-        warnings.warn(
+        logger.warning(
             "qrcode library not available. Install with: pip install qrcode[pil]"
         )
         return fig