Photo-Composition-Designer 0.0.7__py3-none-any.whl

Photo_Composition_Designer/__main__.py

@@ -0,0 +1,8 @@
+"""Entry point for Photo_Composition_Designer."""
+
+import sys  # pragma: no cover
+
+from .cli.cli import main  # pragma: no cover
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())

Photo_Composition_Designer/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.0.7'
+__version_tuple__ = version_tuple = (0, 0, 7)
+
+__commit_id__ = commit_id = None

Photo_Composition_Designer/cli/__main__.py

@@ -0,0 +1,8 @@
+"""CLI entry point for project_name."""
+
+import sys  # pragma: no cover
+
+from .cli import main  # pragma: no cover
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())

Photo_Composition_Designer/cli/cli.py

@@ -0,0 +1,106 @@
+"""CLI interface for Photo-Composition-Designer using the generic config framework.
+
+This file uses the CliGenerator from the generic config framework.
+"""
+
+import os.path
+
+from config_cli_gui.cli import CliGenerator
+
+from Photo_Composition_Designer.common.logging import initialize_logging
+from Photo_Composition_Designer.config.config import ConfigParameterManager
+from Photo_Composition_Designer.core.base import CompositionDesigner
+
+
+def validate_config(config_manager: ConfigParameterManager) -> bool:
+    """Validate the configuration parameters.
+
+    Args:
+        config_manager: Configuration manager instance
+        logger: Logger instance for error reporting
+
+    Returns:
+        True if configuration is valid, False otherwise
+    """
+    # Initialize logging system
+    logger_manager = initialize_logging(config_manager)
+    logger = logger_manager.get_logger("Photo_Composition_Designer.cli")
+
+    # Get CLI category and check required parameters
+    cli_parameters = config_manager.get_cli_parameters()
+    if not cli_parameters:
+        logger.error("No CLI configuration found")
+
+    for param in cli_parameters:
+        if param.name == "photoDirectory":
+            photo_dir = param.value
+            if os.path.exists(photo_dir):
+                logger.debug(f"Input file validation passed: {photo_dir}")
+                return True
+            else:
+                logger.debug(f"Input file not found: {photo_dir}")
+
+    return False
+
+
+def run_main_processing(config_manager: ConfigParameterManager) -> int:
+    """Main processing function that gets called by the CLI generator.
+
+    Args:
+        config_manager: Configuration manager with all settings
+
+    Returns:
+        Exit code (0 for success, non-zero for error)
+    """
+    # Initialize logging system
+    logger_manager = initialize_logging(config_manager)
+    logger = logger_manager.get_logger("Photo_Composition_Designer.cli")
+
+    try:
+        # Log startup information
+        logger.info("Starting Photo_Composition_Designer CLI")
+        logger_manager.log_config_summary()
+
+        # Validate configuration
+        if not validate_config(config_manager):
+            logger.error("Configuration validation failed")
+            return 1
+
+        # Create and run Composition Designer
+        logger.info("Starting conversion process")
+        composition_designer = CompositionDesigner(config_manager)
+        composition_designer.generate_compositions_from_folders()
+        logger.info("Conversion process completed")
+
+        logger.info("CLI processing completed successfully")
+        return 0
+
+    except Exception as e:
+        logger.error(f"Processing failed: {e}")
+        logger.debug("Full traceback:", exc_info=True)
+        return 1
+
+
+def main():
+    """Main entry point for the CLI application."""
+    # Create the base configuration manager
+    config_manager = ConfigParameterManager()
+
+    # Create CLI generator
+    cli_generator = CliGenerator(
+        config_manager=config_manager, app_name="Photo_Composition_Designer"
+    )
+
+    # Run the CLI with our main processing function
+    return cli_generator.run_cli(
+        main_function=run_main_processing,
+        description="Process GPX files with various operations like compression, "
+        "merging, and POI extraction",
+        validator=validate_config,
+    )
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main())

Photo_Composition_Designer/common/Anniversaries.py

@@ -0,0 +1,93 @@
+import os
+from collections import defaultdict
+
+from path_handler import get_base_path
+
+
+class Anniversaries:
+    def __init__(self, anniversaries_file=None):
+        if not anniversaries_file:
+            base_path = get_base_path()
+            anniversaries_file = base_path / "anniversaries.ini"
+
+        self.anniversary_dict = defaultdict(str)  # Dictionary für die Anniversaries
+
+        if not os.path.exists(anniversaries_file):
+            return
+
+        # Preprocess the config file to remove comments and parse lines
+        with open(anniversaries_file, "r", encoding="utf-8") as file:
+            category = None
+            for line in file:
+                # Remove comments and strip whitespace
+                line = line.split(";", 1)[0].strip()
+                if not line:  # Skip empty lines
+                    continue
+
+                # Detect category headers
+                if line.startswith("[") and line.endswith("]"):
+                    category = line[1:-1]  # Extract category name
+                    continue
+
+                # Skip invalid lines without a current category
+                if not category:
+                    continue
+
+                # Process valid data lines within the category
+                self._process_line(line, category)
+
+    def _process_line(self, line, category):
+        """
+        Processes a single line of data and adds it to the anniversary dictionary.
+        """
+        if "=" not in line:
+            return  # Skip malformed lines
+        name, date = map(str.strip, line.split("=", 1))
+
+        day, month, *year = date.split(".")
+        year = int(year[0]) if year and year[0] else None
+
+        # Define label formatters for each category
+        label_formatter = {
+            "Birthdays": lambda _name, _year: f"{_name} {str(_year)[-2:]}" if _year else _name,
+            "Dates of death": lambda _name, _year: f"{_name} ✝ {str(_year)[-2:]}"
+            if _year
+            else f"{_name} ✝",
+            "Weddings": lambda _name, _year: f"{_name} ⚭ {str(_year)[-2:]}"
+            if _year
+            else f"{_name} ⚭",
+        }.get(category, lambda _name, _year: _name)  # Default formatter if category is unknown
+
+        label = label_formatter(name, year)
+        self._add_to_dict(int(day), int(month), label)
+
+    def _add_to_dict(self, day, month, label):
+        """
+        Adds an entry to the dictionary; merges labels in case of conflicts.
+        """
+        key = (day, month)
+        if key in self.anniversary_dict:
+            if label not in self.anniversary_dict[key]:
+                self.anniversary_dict[key] += f", {label}"
+        else:
+            self.anniversary_dict[key] = label
+
+    def __getitem__(self, key):
+        return self.anniversary_dict.get(key)
+
+    def __setitem__(self, key, value):
+        self.anniversary_dict[key] = value
+
+    def __contains__(self, key):
+        return key in self.anniversary_dict
+
+    def items(self):
+        return self.anniversary_dict.items()
+
+    def __repr__(self):
+        return f"Anniversaries({dict(self.anniversary_dict)})"
+
+
+if __name__ == "__main__":
+    annis = Anniversaries()
+    print(annis.items())

Photo_Composition_Designer/common/Locations.py

@@ -0,0 +1,87 @@
+import os
+from collections import defaultdict
+
+from path_handler import get_base_path
+
+
+class Locations:
+    """
+    This class is used to provide position information if it is not saved in the image.
+    This class searches a locations.ini, which has the following structure below.
+
+    It provides a dict that contains locations as tuple:
+
+    [EUROPE]
+    London = 51.5074, -0.1278
+    Bavaria = 48.7904, 11.4979
+
+    [AMERICA]
+    United States = 37.0902, -95.7129
+
+    """
+
+    def __init__(self, locations_file=None):
+        if not locations_file:
+            base_path = get_base_path()
+            locations_file = base_path / "locations_en.ini"
+
+        self.locations_dict = defaultdict(tuple)  # Dictionary for the locations
+
+        if not os.path.exists(locations_file):
+            return
+
+        # Preprocess the config file to remove comments and parse lines
+        with open(locations_file, "r", encoding="utf-8") as file:
+            current_category = None
+            for line in file:
+                # Remove comments and strip whitespace
+                line = line.split(";", 1)[0].strip()
+                if not line:  # Skip empty lines
+                    continue
+
+                # Detect category headers
+                if line.startswith("[") and line.endswith("]"):
+                    current_category = line[1:-1]
+                    continue
+
+                # Process valid data lines within the category
+                self._process_line(line, current_category)
+
+    def _process_line(self, line, category):
+        """
+        Processes a single line of data and adds it to the locations dictionary.
+        """
+        if "=" not in line:
+            return  # Skip malformed lines
+        city, coordinates = map(str.strip, line.split("=", 1))
+        try:
+            lat, lon = map(float, coordinates.split(","))
+            self._add_to_dict(city, (lat, lon), category)
+        except Exception as e:
+            print(f'Error processing line "{line}": {e}')
+
+    def _add_to_dict(self, city: str, coordinates, _):
+        """
+        Adds an entry to the dictionary under the given category.
+        """
+        self.locations_dict[city.lower()] = coordinates
+
+    def __getitem__(self, key):
+        return self.locations_dict.get(key)
+
+    def __setitem__(self, key, value):
+        self.locations_dict[key] = value
+
+    def __contains__(self, key):
+        return key in self.locations_dict
+
+    def items(self):
+        return self.locations_dict.items()
+
+    def __repr__(self):
+        return f"Locations({dict(self.locations_dict)})"
+
+
+if __name__ == "__main__":
+    locations = Locations()
+    print(locations.items())

Photo_Composition_Designer/common/MoonPhase.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from astral import moon
+
+
+class MoonPhase:
+    """Utility class for computing Unicode moon phase symbols."""
+
+    DETAILED = False
+
+    @staticmethod
+    def get_moon_phase_symbol_light(d: datetime) -> str:
+        """
+        Return the Unicode symbol representing the Moon's illuminated
+        phase for the given date.
+
+        This method uses the actual lunar phase from Astral and maps it
+        to a Unicode icon using `get_moon_symbol()`.
+        """
+        return MoonPhase.get_moon_symbol(moon.phase(d))
+
+    @staticmethod
+    def get_moon_phase_symbol_dark(d: datetime) -> str:
+        """
+        Return the Unicode symbol for the Moon as it would appear in
+        an inverted-illumination (dark-mode) scheme. This is helpful
+        for bright background.
+
+        This is computed by shifting the phase forward by 14 (half a
+        lunar cycle), effectively flipping the illuminated side.
+        """
+        return MoonPhase.get_moon_symbol((moon.phase(d) + 14) % 28)
+
+    @staticmethod
+    def get_moon_symbol(phase: float) -> str:
+        """
+        Map an Astral moon-phase value to a Unicode symbol.
+
+        Parameters
+        ----------
+        phase : float
+            The moon phase value from Astral (0–29.53 approx).
+
+        Returns
+        -------
+        str
+            A Unicode moon-phase emoji corresponding to the integer
+            phase bucket. Only major phases are returned unless
+            `DETAILED` is enabled.
+
+        Notes
+        -----
+        Recognized phases:
+
+            0   → 🌑  new moon
+            4   → 🌒  waxing crescent      (detailed mode only)
+            7   → 🌓  first quarter
+            10  → 🌔  waxing gibbous       (detailed mode only)
+            14  → 🌕  full moon
+            18  → 🌖  waning gibbous       (detailed mode only)
+            21  → 🌗  last quarter
+            25  → 🌘  waning crescent      (detailed mode only)
+
+        All other values return the empty string.
+        """
+        p = int(phase)
+        if p == 0:
+            return "🌑"
+        if p == 4 and MoonPhase.DETAILED:
+            return "🌒"
+        if p == 7:
+            return "🌓"
+        if p == 10 and MoonPhase.DETAILED:
+            return "🌔"
+        if p == 14:
+            return "🌕"
+        if p == 18 and MoonPhase.DETAILED:
+            return "🌖"
+        if p == 21:
+            return "🌗"
+        if p == 25 and MoonPhase.DETAILED:
+            return "🌘"
+        return ""

Photo_Composition_Designer/common/Photo.py

@@ -0,0 +1,113 @@
+import os
+import re
+from datetime import datetime
+from pathlib import Path
+
+import exifread
+from PIL import Image
+
+
+class Photo:
+    DATE_PATTERN_FULL = re.compile(
+        r"(?:(\d{4})[-_]?(\d{2})[-_]?(\d{2})[-_]?(\d{2})[-_]?(\d{2})[-_]?(\d{2}))"
+    )
+    DATE_PATTERN_NO_TIME = re.compile(r"(?:(\d{4})[-_]?(\d{2})[-_]?(\d{2}))")
+
+    def __init__(self, file_path: Path, locations=None):
+        self.file_path: Path = Path(file_path)
+        self._locations: dict[str, tuple[float, float]] = locations
+        if not self.file_path.exists():
+            raise FileNotFoundError(f"File not found: {self.file_path}")
+
+    def get_location(self) -> tuple[float, float] | None:
+        return self.get_location_from_exif() or self.get_location_from_name()
+
+    def get_location_from_exif(self) -> tuple[float, float] | None:
+        """Returns the GPS coordinates from EXIF data if available."""
+        with open(self.file_path, "rb") as img_file:
+            tags = exifread.process_file(img_file, details=False)
+            if "GPS GPSLatitude" in tags and "GPS GPSLongitude" in tags:
+                lat = self._convert_to_decimal(tags["GPS GPSLatitude"].values)
+                lon = self._convert_to_decimal(tags["GPS GPSLongitude"].values)
+                if tags.get("GPS GPSLatitudeRef") and tags["GPS GPSLatitudeRef"].values[0] == "S":
+                    lat = -lat
+                if tags.get("GPS GPSLongitudeRef") and tags["GPS GPSLongitudeRef"].values[0] == "W":
+                    lon = -lon
+                return lat, lon
+        return None
+
+    def get_location_from_name(self) -> tuple[float, float] | None:
+        location = self._locations
+        file_name = self.file_path.name.lower()
+
+        for place in location:
+            if re.search(rf"\b{re.escape(place.lower())}\b", file_name):
+                return location[place]
+
+        return None
+
+    def get_date(self) -> datetime | None:
+        """Returns the date from EXIF data or filename if available."""
+        date = self._extract_date_from_exif()
+        if date:
+            return date
+        return self._extract_date_from_filename()
+
+    def get_image(self) -> Image.Image | None:
+        """Returns an Image object if the file can be opened."""
+        try:
+            return Image.open(self.file_path)
+        except Exception as e:
+            print(f"Error opening image: {e}")
+            return None
+
+    @staticmethod
+    def _convert_to_decimal(dms) -> float:
+        """Converts degrees, minutes, and seconds to decimal degrees."""
+        return float(dms[0]) + float(dms[1]) / 60 + float(dms[2]) / 3600
+
+    def _extract_date_from_exif(self) -> datetime | None:
+        """Reads EXIF date, if available."""
+        with open(self.file_path, "rb") as img_file:
+            tags = exifread.process_file(img_file, details=False)
+            if "EXIF DateTimeOriginal" in tags:
+                try:
+                    date_str = str(tags["EXIF DateTimeOriginal"])
+                    return datetime.strptime(date_str, "%Y:%m:%d %H:%M:%S")
+                except ValueError:
+                    pass
+        return None
+
+    def _extract_date_from_filename(self) -> datetime | None:
+        """Attempts to extract date from file name."""
+        match = self.DATE_PATTERN_FULL.search(self.file_path.name)
+        if match:
+            return datetime(*map(int, match.groups()))
+        match = self.DATE_PATTERN_NO_TIME.search(self.file_path.name)
+        if match:
+            return datetime(*map(int, match.groups()), 12, 0, 0)
+        return datetime.max
+
+
+def get_photos_from_dir(
+    image_folder: Path, locations: dict[str, tuple[float, float]] = None
+) -> list["Photo"] | None:
+    """Liest alle Bilddateien aus einem Ordner ein und gibt eine Liste von Photo-Objekten zurück."""
+
+    folder_path = Path(image_folder)
+
+    if not folder_path.is_dir():
+        raise ValueError(f"Folder '{image_folder}' does not exist.")
+
+    # Alle Bilddateien sammeln
+    image_files = [
+        os.path.join(image_folder, file)
+        for file in sorted(os.listdir(image_folder))
+        if file.lower().endswith((".png", ".jpg", ".jpeg"))
+    ]
+
+    if not image_files:
+        print(f"No images found in '{image_folder}'.")
+        return None
+
+    return [Photo(Path(file), locations) for file in image_files]  # Photo-Objekte erstellen