fotolab 0.28.6__tar.gz → 0.29.1__tar.gz

{fotolab-0.28.6 → fotolab-0.29.1}/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [0-based versioning](https://0ver.org/).
 
 ## [Unreleased]
 
+## v0.29.1 (2025-05-04)
+
+- Improve camera metadata handling in watermark subcommand.
+- Refactor halftone dot drawing into a separate function for clarity
+- Refactor halftone dot drawing to use NamedTuple for cell data
+- Refactor info subcommand to handle specific metadata requests.
+- Update help message in readme
+
+## v0.29.0 (2025-04-27)
+
+- Add `cells` argument to halftone subcommand and function
+- Add grayscale option to halftone subcommand for grayscale conversion
+- Bump deps
+- Calculate dot radius relative to cell size based on brightness.
+- Refactor CLI to handle missing subcommand execution function gracefully
+- Require a subcommand to be specified and remove redundant checks
+
 ## v0.28.6 (2025-04-20)
 
 - Add missing typehints for `watermark` subcommand

{fotolab-0.28.6 → fotolab-0.29.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fotolab
-Version: 0.28.6
+Version: 0.29.1
 Summary: A console program that manipulate images.
 Keywords: photography,photo
 Author-email: Kian-Meng Ang <kianmeng@cpan.org>
@@ -75,7 +75,7 @@ positional arguments:
     animate         animate an image
     auto            auto adjust (resize, contrast, and watermark) a photo
     border          add border to image
-    contrast        contrast an image
+    contrast        contrast an image.
     env             print environment information for bug reporting
     halftone        halftone an image
     info            info an image
@@ -200,8 +200,8 @@ positional arguments:
 
 options:
   -h, --help            show this help message and exit
-  -c, --cutoff CUTOFF   set the percentage of lightest or darkest pixels to
-                        discard from histogram (default: '1')
+  -c, --cutoff CUTOFF   set the percentage (0-50) of lightest or darkest
+                        pixels to discard from histogram (default: '1.0')
   -op, --open           open the image using default program (default:
                         'False')
   -od, --output-dir OUTPUT_DIR

{fotolab-0.28.6 → fotolab-0.29.1}/Pipfile.lock

@@ -1,7 +1,7 @@
 {
     "_meta": {
         "hash": {
-            "sha256": "0ae04620e58fea48a693d99901d3c9f3a1992033a0a3b8eac3306e6ca34f65bb"
+            "sha256": "52a8d63c6f19800a1bd1586e2773e76ce235140a359f64eb68e0dbb72a2dd138"
         },
         "pipfile-spec": 6,
         "requires": {

{fotolab-0.28.6 → fotolab-0.29.1}/README.md

@@ -52,7 +52,7 @@ positional arguments:
     animate         animate an image
     auto            auto adjust (resize, contrast, and watermark) a photo
     border          add border to image
-    contrast        contrast an image
+    contrast        contrast an image.
     env             print environment information for bug reporting
     halftone        halftone an image
     info            info an image
@@ -177,8 +177,8 @@ positional arguments:
 
 options:
   -h, --help            show this help message and exit
-  -c, --cutoff CUTOFF   set the percentage of lightest or darkest pixels to
-                        discard from histogram (default: '1')
+  -c, --cutoff CUTOFF   set the percentage (0-50) of lightest or darkest
+                        pixels to discard from histogram (default: '1.0')
   -op, --open           open the image using default program (default:
                         'False')
   -od, --output-dir OUTPUT_DIR

{fotolab-0.28.6 → fotolab-0.29.1}/fotolab/__init__.py

@@ -24,7 +24,7 @@ from pathlib import Path
 
 from PIL import Image
 
-__version__ = "0.28.6"
+__version__ = "0.29.1"
 
 log = logging.getLogger(__name__)
 

{fotolab-0.28.6 → fotolab-0.29.1}/fotolab/cli.py

@@ -115,6 +115,7 @@ def build_parser() -> argparse.ArgumentParser:
     subparsers = parser.add_subparsers(
         help="sub-command help",
         dest="command",
+        required=True,
     )
     fotolab.subcommands.build_subparser(subparsers)
 
@@ -128,16 +129,24 @@ def main(args: Optional[Sequence[str]] = None) -> None:
 
     try:
         parser = build_parser()
-        if len(args) == 0:
-            parser.print_help(sys.stderr)
-            return
-
         parsed_args = parser.parse_args(args)
         setup_logging(parsed_args)
 
-        if hasattr(parsed_args, "func"):
+        if parsed_args.command is not None:
             log.debug(parsed_args)
-            parsed_args.func(parsed_args)
+            # Ensure the function attribute exists (set by set_defaults in
+            # subcommands)
+            if hasattr(parsed_args, "func"):
+                parsed_args.func(parsed_args)
+            else:
+                # This case should ideally not happen if subcommands are set up
+                # correctly
+                log.error(
+                    "subcommand '%s' is missing its execution function.",
+                    parsed_args.command
+                )
+                parser.print_help(sys.stderr)
+                raise SystemExit(1)
         else:
             parser.print_help(sys.stderr)
 

fotolab-0.29.1/fotolab/subcommands/halftone.py

@@ -0,0 +1,229 @@
+# Copyright (C) 2024,2025 Kian-Meng Ang
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+"""Halftone subcommand."""
+
+import argparse
+import logging
+import math
+from typing import NamedTuple
+
+from PIL import Image, ImageDraw
+
+from fotolab import save_gif_image, save_image
+
+log = logging.getLogger(__name__)
+
+
+class HalftoneCell(NamedTuple):
+    """Represents a cell in the halftone grid."""
+
+    col: int
+    row: int
+    cellsize: float
+
+
+def build_subparser(subparsers) -> None:
+    """Build the subparser."""
+    halftone_parser = subparsers.add_parser(
+        "halftone", help="halftone an image"
+    )
+
+    halftone_parser.set_defaults(func=run)
+
+    halftone_parser.add_argument(
+        dest="image_filenames",
+        help="set the image filename",
+        nargs="+",
+        type=str,
+        default=None,
+        metavar="IMAGE_FILENAMES",
+    )
+
+    halftone_parser.add_argument(
+        "-ba",
+        "--before-after",
+        default=False,
+        action="store_true",
+        dest="before_after",
+        help="generate a GIF showing before and after changes",
+    )
+
+    halftone_parser.add_argument(
+        "-op",
+        "--open",
+        default=False,
+        action="store_true",
+        dest="open",
+        help="open the image using default program (default: '%(default)s')",
+    )
+
+    halftone_parser.add_argument(
+        "-od",
+        "--output-dir",
+        dest="output_dir",
+        default="output",
+        help="set default output folder (default: '%(default)s')",
+    )
+
+    halftone_parser.add_argument(
+        "-c",
+        "--cells",
+        dest="cells",
+        type=int,
+        default=50,
+        help="set number of cells across the image width (default: %(default)s)",
+    )
+
+    halftone_parser.add_argument(
+        "-g",
+        "--grayscale",
+        default=False,
+        action="store_true",
+        dest="grayscale",
+        help="convert image to grayscale before applying halftone",
+    )
+
+
+def run(args: argparse.Namespace) -> None:
+    """Run halftone subcommand.
+
+    Args:
+        args (argparse.Namespace): Config from command line arguments
+
+    Returns:
+        None
+    """
+    log.debug(args)
+
+    for image_filename in args.image_filenames:
+        original_image = Image.open(image_filename)
+        halftone_image = create_halftone_image(
+            original_image, args.cells, args.grayscale
+        )
+
+        if args.before_after:
+            save_gif_image(
+                args,
+                image_filename,
+                original_image,
+                halftone_image,
+                "halftone",
+            )
+        else:
+            save_image(args, halftone_image, image_filename, "halftone")
+
+
+def _draw_halftone_dot(
+    draw: ImageDraw.ImageDraw,
+    source_image: Image.Image,
+    cell: HalftoneCell,
+    grayscale: bool,
+    fill_color_dot,
+) -> None:
+    """Calculate properties and draw a single halftone dot."""
+    # Calculate center point of current cell
+    img_width, img_height = source_image.size
+
+    # Calculate center point of current cell and clamp to image bounds
+    x = min(int(cell.col * cell.cellsize + cell.cellsize / 2), img_width - 1)
+    y = min(int(cell.row * cell.cellsize + cell.cellsize / 2), img_height - 1)
+
+    # Ensure coordinates are non-negative (shouldn't happen with current logic, but safe)
+    x = max(0, x)
+    y = max(0, y)
+
+    # Get pixel value (brightness or color) from the source image using clamped coordinates
+    pixel_value = source_image.getpixel((x, y))
+
+    if grayscale:
+        brightness = pixel_value
+        dot_fill = fill_color_dot  # Use white for grayscale dots
+    else:
+        # Calculate brightness (luminance) from the RGB color
+        brightness = int(
+            0.299 * pixel_value[0]
+            + 0.587 * pixel_value[1]
+            + 0.114 * pixel_value[2]
+        )
+        dot_fill = pixel_value  # Use original color for color dots
+
+    # Calculate dot radius relative to cell size based on brightness
+    # Max radius is half the cell size. Scale by brightness (0-255).
+    dot_radius = (brightness / 255.0) * (cell.cellsize / 2)
+
+    # Draw the dot
+    draw.ellipse(
+        [
+            x - dot_radius,
+            y - dot_radius,
+            x + dot_radius,
+            y + dot_radius,
+        ],
+        fill=dot_fill,
+    )
+
+
+def create_halftone_image(
+    original_image: Image.Image, cell_count: int, grayscale: bool = False
+) -> Image.Image:
+    """Create a halftone version of the input image.
+
+    Modified from the circular halftone effect processing.py example from
+    https://tabreturn.github.io/code/processing/python/2019/02/09/processing.py_in_ten_lessons-6.3-_halftones.html
+
+    Args:
+        original_image: The source image to convert
+        cell_count: Number of cells across the width
+        grayscale: Whether to convert to grayscale first (default: False)
+
+    Returns:
+        Image.Image: The halftone converted image
+    """
+    if grayscale:
+        source_image = original_image.convert("L")
+        output_mode = "L"
+        fill_color_black = 0
+        fill_color_dot = 255
+    else:
+        source_image = original_image.convert("RGB")
+        output_mode = "RGB"
+        fill_color_black = (0, 0, 0)
+        fill_color_dot = None  # Will be set inside the loop for color images
+
+    width, height = original_image.size
+
+    # Create a new image for the output, initialized to black
+    halftone_image = Image.new(output_mode, (width, height), fill_color_black)
+    draw = ImageDraw.Draw(halftone_image)
+
+    cellsize = width / cell_count
+    rowtotal = math.ceil(height / cellsize)
+
+    # Determine the fill color for dots once if grayscale
+    grayscale_fill_color_dot = fill_color_dot if grayscale else None
+
+    for row in range(rowtotal):
+        for col in range(cell_count):
+            cell = HalftoneCell(col=col, row=row, cellsize=cellsize)
+            _draw_halftone_dot(
+                draw,
+                source_image,
+                cell,
+                grayscale,
+                grayscale_fill_color_dot,
+            )
+
+    return halftone_image

{fotolab-0.28.6 → fotolab-0.29.1}/fotolab/subcommands/info.py

@@ -74,25 +74,41 @@ def run(args: argparse.Namespace) -> None:
     """
     log.debug(args)
 
-    info = []
+    # TODO: Add error handling for file open
+    # TODO: Use context manager `with Image.open(...)`
     image = Image.open(args.image_filename)
 
+    exif_tags = extract_exif_tags(image, args.sort)
+
+    if not exif_tags:
+        print("No metadata found!")
+        # Close the image if opened outside a 'with' block
+        image.close()
+        return
+
+    output_info = []
+    specific_info_requested = False
+
     if args.camera:
-        info.append(camera_metadata(image))
+        specific_info_requested = True
+        # TODO: Add error handling for missing keys
+        output_info.append(camera_metadata(exif_tags))
 
     if args.datetime:
-        info.append(datetime(image))
+        specific_info_requested = True
+        # TODO: Add error handling for missing keys
+        output_info.append(datetime(exif_tags))
 
-    if info:
-        print("\n".join(info))
+    if specific_info_requested:
+        print("\n".join(output_info))
     else:
-        exif_tags = extract_exif_tags(image)
-        if exif_tags:
-            tag_name_width = max(map(len, exif_tags))
-            for tag_name, tag_value in exif_tags.items():
-                print(f"{tag_name:<{tag_name_width}}: {tag_value}")
-        else:
-            print("No metadata found!")
+        # Print all tags if no specific info was requested
+        tag_name_width = max(map(len, exif_tags))
+        for tag_name, tag_value in exif_tags.items():
+            print(f"{tag_name:<{tag_name_width}}: {tag_value}")
+
+    # Close the image if opened outside a 'with' block
+    image.close()
 
 
 def extract_exif_tags(image: Image.Image, sort: bool = False) -> dict:
@@ -117,14 +133,16 @@ def extract_exif_tags(image: Image.Image, sort: bool = False) -> dict:
     return filtered_info
 
 
-def datetime(image: Image.Image):
+def datetime(exif_tags: dict):
     """Extract datetime metadata."""
-    exif_tags = extract_exif_tags(image)
+    # TODO: Add error handling for missing key
     return exif_tags["DateTime"]
 
 
-def camera_metadata(image: Image.Image):
+def camera_metadata(exif_tags: dict):
     """Extract camera and model metadata."""
-    exif_tags = extract_exif_tags(image)
-    metadata = f'{exif_tags["Make"]} {exif_tags["Model"]}'
+    # TODO: Add error handling for missing keys
+    make = exif_tags.get("Make", "")
+    model = exif_tags.get("Model", "")
+    metadata = f"{make} {model}"
     return metadata.strip()

{fotolab-0.28.6 → fotolab-0.29.1}/fotolab/subcommands/watermark.py

@@ -281,9 +281,17 @@ def watermark_image(
 
 def prepare_text(args: argparse.Namespace, image: Image.Image) -> str:
     """Prepare the watermark text."""
-    text: str = args.text
-    if args.camera and camera_metadata(image):
-        text = camera_metadata(image)
+    text: str = args.text  # Default text
+    if args.camera:
+        metadata_text: str | None = camera_metadata(image)
+        if metadata_text:  # Use metadata only if it's not None or empty
+            text = metadata_text
+        else:
+            log.warning(
+                "Camera metadata requested but not found or empty; "
+                "falling back to default text: '%s'",
+                args.text,
+            )
 
     if args.lowercase:
         text = text.lower()

fotolab-0.28.6/fotolab/subcommands/halftone.py

@@ -1,145 +0,0 @@
-# Copyright (C) 2024,2025 Kian-Meng Ang
-#
-# This program is free software: you can redistribute it and/or modify it under
-# the terms of the GNU Affero General Public License as published by the Free
-# Software Foundation, either version 3 of the License, or (at your option) any
-# later version.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-# details.
-#
-# You should have received a copy of the GNU Affero General Public License
-# along with this program. If not, see <https://www.gnu.org/licenses/>.
-
-"""Halftone subcommand."""
-
-import argparse
-import logging
-import math
-
-from PIL import Image, ImageDraw
-
-from fotolab import save_gif_image, save_image
-
-log = logging.getLogger(__name__)
-
-
-def build_subparser(subparsers) -> None:
-    """Build the subparser."""
-    halftone_parser = subparsers.add_parser(
-        "halftone", help="halftone an image"
-    )
-
-    halftone_parser.set_defaults(func=run)
-
-    halftone_parser.add_argument(
-        dest="image_filenames",
-        help="set the image filename",
-        nargs="+",
-        type=str,
-        default=None,
-        metavar="IMAGE_FILENAMES",
-    )
-
-    halftone_parser.add_argument(
-        "-ba",
-        "--before-after",
-        default=False,
-        action="store_true",
-        dest="before_after",
-        help="generate a GIF showing before and after changes",
-    )
-
-    halftone_parser.add_argument(
-        "-op",
-        "--open",
-        default=False,
-        action="store_true",
-        dest="open",
-        help="open the image using default program (default: '%(default)s')",
-    )
-
-    halftone_parser.add_argument(
-        "-od",
-        "--output-dir",
-        dest="output_dir",
-        default="output",
-        help="set default output folder (default: '%(default)s')",
-    )
-
-
-def run(args: argparse.Namespace) -> None:
-    """Run halftone subcommand.
-
-    Args:
-        args (argparse.Namespace): Config from command line arguments
-
-    Returns:
-        None
-    """
-    log.debug(args)
-
-    for image_filename in args.image_filenames:
-        original_image = Image.open(image_filename)
-        halftone_image = create_halftone_image(original_image)
-
-        if args.before_after:
-            save_gif_image(
-                args,
-                image_filename,
-                original_image,
-                halftone_image,
-                "halftone",
-            )
-        else:
-            save_image(args, halftone_image, image_filename, "halftone")
-
-
-def create_halftone_image(
-    original_image: Image.Image, cell_count: int = 50
-) -> Image.Image:
-    """Create a halftone version of the input image.
-
-    Modified from the circular halftone effect processing.py example from
-    https://tabreturn.github.io/code/processing/python/2019/02/09/processing.py_in_ten_lessons-6.3-_halftones.html
-
-    Args:
-        original_image: The source image to convert
-        cell_count: Number of cells across the width (default: 50)
-
-    Returns:
-        Image.Image: The halftone converted image
-    """
-    grayscale_image = original_image.convert("L")
-    width, height = original_image.size
-
-    halftone_image = Image.new("L", (width, height), "black")
-    draw = ImageDraw.Draw(halftone_image)
-
-    cellsize = width / cell_count
-    rowtotal = math.ceil(height / cellsize)
-
-    for row in range(rowtotal):
-        for col in range(cell_count):
-            # Calculate center point of current cell
-            x = int(col * cellsize + cellsize / 2)
-            y = int(row * cellsize + cellsize / 2)
-
-            # Get brightness and calculate dot size
-            brightness = grayscale_image.getpixel((x, y))
-            dot_size = 10 * brightness / 200
-
-            # Draw the dot
-            draw.ellipse(
-                [
-                    x - dot_size / 2,
-                    y - dot_size / 2,
-                    x + dot_size / 2,
-                    y + dot_size / 2,
-                ],
-                fill=255,
-            )
-
-    return halftone_image