fotolab 0.21.1__py3-none-any.whl

fotolab/__init__.py

@@ -0,0 +1,67 @@
+# Copyright (C) 2024 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/>.
+
+"""A console program that manipulate images."""
+
+import logging
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+__version__ = "0.21.1"
+
+log = logging.getLogger(__name__)
+
+
+def save_image(args, new_image, output_filename, subcommand):
+    """Save image after image operation.
+
+    Args:
+        args (argparse.Namespace): Config from command line arguments
+        new_image(PIL.Image.Image): Modified image
+        subcommand(str): Subcommand used to call this function
+
+    Returns:
+        None
+    """
+    image_file = Path(output_filename)
+
+    if args.overwrite:
+        new_filename = image_file.with_name(image_file.name)
+    else:
+        new_filename = Path(
+            args.output_dir,
+            image_file.with_name(f"{subcommand}_{image_file.name}"),
+        )
+        new_filename.parent.mkdir(parents=True, exist_ok=True)
+
+    log.info("%s image: %s", subcommand, new_filename.resolve())
+    new_image.save(new_filename)
+
+    if args.open:
+        _open_image(new_filename)
+
+
+def _open_image(filename):
+    """Open generated image using default program."""
+    if sys.platform == "linux":
+        subprocess.call(["xdg-open", filename])
+    elif sys.platform == "darwin":
+        subprocess.call(["open", filename])
+    elif sys.platform == "windows":
+        os.startfile(filename)
+
+    log.info("open image: %s", filename.resolve())

fotolab/__main__.py

@@ -0,0 +1,22 @@
+# Copyright (C) 2023 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/>.
+
+"""Main entry point when running as module."""
+
+from fotolab.cli import main
+
+if __name__ == "__main__":
+    main()
+    raise SystemExit()

fotolab/animate.py

@@ -0,0 +1,114 @@
+# Copyright (C) 2024 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/>.
+
+"""Animate subcommand."""
+
+import argparse
+import logging
+from pathlib import Path
+
+from PIL import Image
+
+from fotolab import _open_image
+
+log = logging.getLogger(__name__)
+
+
+def build_subparser(subparsers) -> None:
+    """Build the subparser."""
+    animate_parser = subparsers.add_parser("animate", help="animate an image")
+
+    animate_parser.set_defaults(func=run)
+
+    animate_parser.add_argument(
+        dest="image_filenames",
+        help="set the image filenames",
+        nargs="+",
+        type=str,
+        default=None,
+        metavar="IMAGE_FILENAMES",
+    )
+
+    animate_parser.add_argument(
+        "-f",
+        "--format",
+        dest="format",
+        type=str,
+        choices=["gif", "webp"],
+        default="gif",
+        help="set the image format (default: '%(default)s')",
+        metavar="FORMAT",
+    )
+
+    animate_parser.add_argument(
+        "-d",
+        "--duration",
+        dest="duration",
+        type=int,
+        default=2500,
+        help="set the duration in milliseconds (default: '%(default)s')",
+        metavar="DURATION",
+    )
+
+    animate_parser.add_argument(
+        "-l",
+        "--loop",
+        dest="loop",
+        type=int,
+        default=0,
+        help="set the loop cycle (default: '%(default)s')",
+        metavar="LOOP",
+    )
+
+
+def run(args: argparse.Namespace) -> None:
+    """Run animate subcommand.
+
+    Args:
+        config (argparse.Namespace): Config from command line arguments
+
+    Returns:
+        None
+    """
+    log.debug(args)
+
+    first_image = args.image_filenames[0]
+    animated_image = Image.open(first_image)
+
+    append_images = []
+    for image_filename in args.image_filenames[1:]:
+        append_images.append(Image.open(image_filename))
+
+    image_file = Path(first_image)
+    new_filename = Path(
+        args.output_dir,
+        image_file.with_name(f"animate_{image_file.stem}.{args.format}"),
+    )
+    new_filename.parent.mkdir(parents=True, exist_ok=True)
+
+    log.info("animate image: %s", new_filename)
+
+    animated_image.save(
+        new_filename,
+        format=args.format,
+        append_images=append_images,
+        save_all=True,
+        duration=args.duration,
+        loop=args.loop,
+        optimize=True,
+    )
+
+    if args.open:
+        _open_image(new_filename)

fotolab/auto.py

@@ -0,0 +1,83 @@
+# Copyright (C) 2024 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/>.
+
+"""Auto subcommand."""
+
+import argparse
+import logging
+
+import fotolab.contrast
+import fotolab.resize
+import fotolab.sharpen
+import fotolab.watermark
+
+log = logging.getLogger(__name__)
+
+
+def build_subparser(subparsers) -> None:
+    """Build the subparser."""
+    auto_parser = subparsers.add_parser(
+        "auto", help="auto adjust (resize, contrast, and watermark) a photo"
+    )
+
+    auto_parser.set_defaults(func=run)
+
+    auto_parser.add_argument(
+        dest="image_filenames",
+        help="set the image filename",
+        nargs="+",
+        type=str,
+        default=None,
+        metavar="IMAGE_FILENAMES",
+    )
+
+
+def run(args: argparse.Namespace) -> None:
+    """Run auto subcommand.
+
+    Args:
+        config (argparse.Namespace): Config from command line arguments
+
+    Returns:
+        None
+    """
+    extra_args = {
+        "width": 600,
+        "height": 277,
+        "cutoff": 1,
+        "radius": 1,
+        "percent": 100,
+        "threshold": 2,
+        "text": "kianmeng.org",
+        "position": "bottom-left",
+        "font_size": 12,
+        "font_color": "white",
+        "outline_width": 2,
+        "outline_color": "black",
+        "padding": 15,
+        "camera": False,
+        "canvas": False,
+        "lowercase": False,
+    }
+    combined_args = argparse.Namespace(**vars(args), **extra_args)
+    combined_args.overwrite = True
+    combined_args.open = False
+    log.debug(args)
+    log.debug(combined_args)
+
+    fotolab.resize.run(combined_args)
+    fotolab.contrast.run(combined_args)
+    fotolab.sharpen.run(combined_args)
+    fotolab.watermark.run(combined_args)

fotolab/border.py

@@ -0,0 +1,139 @@
+# Copyright (C) 2024 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/>.
+
+"""Border subcommand."""
+
+import argparse
+import logging
+
+from PIL import Image, ImageColor, ImageOps
+
+from fotolab import save_image
+
+log = logging.getLogger(__name__)
+
+
+def build_subparser(subparsers) -> None:
+    """Build the subparser."""
+    border_parser = subparsers.add_parser("border", help="add border to image")
+
+    border_parser.set_defaults(func=run)
+
+    border_parser.add_argument(
+        dest="image_filenames",
+        help="set the image filenames",
+        nargs="+",
+        type=str,
+        default=None,
+        metavar="IMAGE_FILENAMES",
+    )
+
+    border_parser.add_argument(
+        "-c",
+        "--color",
+        dest="color",
+        type=str,
+        default="black",
+        help="set the color of border (default: '%(default)s')",
+        metavar="COLOR",
+    )
+
+    border_parser.add_argument(
+        "-w",
+        "--width",
+        dest="width",
+        type=str,
+        default=10,
+        help="set the width of border (default: '%(default)s')",
+        metavar="WIDTH",
+    )
+
+    border_parser.add_argument(
+        "-wt",
+        "--width-top",
+        dest="width_top",
+        type=str,
+        default=0,
+        help="set the width of top border (default: '%(default)s')",
+        metavar="WIDTH",
+    )
+
+    border_parser.add_argument(
+        "-wr",
+        "--width-right",
+        dest="width_right",
+        type=str,
+        default=0,
+        help="set the width of right border (default: '%(default)s')",
+        metavar="WIDTH",
+    )
+
+    border_parser.add_argument(
+        "-wb",
+        "--width-bottom",
+        dest="width_bottom",
+        type=str,
+        default=0,
+        help="set the width of bottom border (default: '%(default)s')",
+        metavar="WIDTH",
+    )
+
+    border_parser.add_argument(
+        "-wl",
+        "--width-left",
+        dest="width_left",
+        type=str,
+        default=0,
+        help="set the width of left border (default: '%(default)s')",
+        metavar="WIDTH",
+    )
+
+
+def run(args: argparse.Namespace) -> None:
+    """Run border subcommand.
+
+    Args:
+        config (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)
+
+        if (
+            args.width_left
+            or args.width_top
+            or args.width_right
+            or args.width_bottom
+        ):
+            border = (
+                int(args.width_left),
+                int(args.width_top),
+                int(args.width_right),
+                int(args.width_bottom),
+            )
+        else:
+            border = args.width
+
+        bordered_image = ImageOps.expand(
+            original_image,
+            border=border,
+            fill=ImageColor.getrgb(args.color),
+        )
+
+        save_image(args, bordered_image, image_filename, "watermark")

fotolab/cli.py

@@ -0,0 +1,180 @@
+# Copyright (c) 2024 Kian-Meng Ang
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU 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 Generals Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""A console program to manipulate photos.
+
+  website: https://github.com/kianmeng/fotolab
+  changelog: https://github.com/kianmeng/fotolab/blob/master/CHANGELOG.md
+  issues: https://github.com/kianmeng/fotolab/issues
+"""
+
+import argparse
+import logging
+import sys
+from typing import Dict, Optional, Sequence
+
+import fotolab.animate
+import fotolab.auto
+import fotolab.border
+import fotolab.contrast
+import fotolab.env
+import fotolab.info
+import fotolab.montage
+import fotolab.resize
+import fotolab.rotate
+import fotolab.sharpen
+import fotolab.watermark
+from fotolab import __version__
+
+log = logging.getLogger(__name__)
+
+
+def setup_logging(args: argparse.Namespace) -> None:
+    """Set up logging by level."""
+    if args.verbose == 0:
+        logging.getLogger("PIL").setLevel(logging.ERROR)
+
+    if args.quiet:
+        logging.disable(logging.NOTSET)
+    else:
+        conf: Dict = {
+            True: {
+                "level": logging.DEBUG,
+                "msg": "[%(asctime)s] %(levelname)s: %(name)s: %(message)s",
+            },
+            False: {"level": logging.INFO, "msg": "%(message)s"},
+        }
+
+        logging.basicConfig(
+            level=conf[args.debug]["level"],
+            stream=sys.stdout,
+            format=conf[args.debug]["msg"],
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the CLI parser."""
+    parser = argparse.ArgumentParser(
+        prog="fotolab",
+        description=__doc__,
+        formatter_class=lambda prog: argparse.RawTextHelpFormatter(
+            prog, max_help_position=20
+        ),
+    )
+
+    parser.add_argument(
+        "-o",
+        "--overwrite",
+        default=False,
+        action="store_true",
+        dest="overwrite",
+        help="overwrite existing image",
+    )
+
+    parser.add_argument(
+        "-op",
+        "--open",
+        default=False,
+        action="store_true",
+        dest="open",
+        help="open the image using default program (default: '%(default)s')",
+    )
+
+    parser.add_argument(
+        "-od",
+        "--output-dir",
+        dest="output_dir",
+        default="output",
+        help="set default output folder (default: '%(default)s')",
+    )
+
+    parser.add_argument(
+        "-q",
+        "--quiet",
+        default=False,
+        action="store_true",
+        dest="quiet",
+        help="suppress all logging",
+    )
+
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        default=0,
+        action="count",
+        dest="verbose",
+        help="show verbosity of debugging log, use -vv, -vvv for more details",
+    )
+
+    parser.add_argument(
+        "-d",
+        "--debug",
+        default=False,
+        action="store_true",
+        dest="debug",
+        help="show debugging log and stacktrace",
+    )
+
+    parser.add_argument(
+        "-V",
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+
+    subparsers = parser.add_subparsers(help="sub-command help")
+    fotolab.animate.build_subparser(subparsers)
+    fotolab.auto.build_subparser(subparsers)
+    fotolab.border.build_subparser(subparsers)
+    fotolab.contrast.build_subparser(subparsers)
+    fotolab.info.build_subparser(subparsers)
+    fotolab.resize.build_subparser(subparsers)
+    fotolab.rotate.build_subparser(subparsers)
+    fotolab.montage.build_subparser(subparsers)
+    fotolab.sharpen.build_subparser(subparsers)
+    fotolab.watermark.build_subparser(subparsers)
+    fotolab.env.build_subparser(subparsers)
+
+    return parser
+
+
+def main(args: Optional[Sequence[str]] = None) -> None:
+    """Run the main program flow."""
+    args = args or sys.argv[1:]
+    log.debug(args)
+
+    try:
+        parser = build_parser()
+        if len(args) == 0:
+            parser.print_help(sys.stderr)
+        else:
+            parsed_args = parser.parse_args(args)
+            setup_logging(parsed_args)
+
+            if hasattr(parsed_args, "func"):
+                log.debug(parsed_args)
+                parsed_args.func(parsed_args)
+            else:
+                parser.print_help(sys.stderr)
+
+    except Exception as error:
+        log.error(
+            "error: %s",
+            getattr(error, "message", str(error)),
+            exc_info=("-d" in args or "--debug" in args),
+        )
+
+        raise SystemExit(1) from None

fotolab/contrast.py

@@ -0,0 +1,77 @@
+# Copyright (C) 2024 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/>.
+
+"""Contrast subcommand."""
+
+import argparse
+import logging
+
+from PIL import Image, ImageOps
+
+from fotolab import save_image
+
+log = logging.getLogger(__name__)
+
+
+def build_subparser(subparsers) -> None:
+    """Build the subparser."""
+    contrast_parser = subparsers.add_parser(
+        "contrast", help="contrast an image"
+    )
+
+    contrast_parser.set_defaults(func=run)
+
+    contrast_parser.add_argument(
+        dest="image_filenames",
+        help="set the image filename",
+        nargs="+",
+        type=str,
+        default=None,
+        metavar="IMAGE_FILENAMES",
+    )
+
+    contrast_parser.add_argument(
+        "-c",
+        "--cutoff",
+        dest="cutoff",
+        type=float,
+        default=1,
+        help=(
+            "set the percentage of lightest or darkest pixels"
+            " to discard from histogram"
+            " (default: '%(default)s')"
+        ),
+        metavar="CUTOFF",
+    )
+
+
+def run(args: argparse.Namespace) -> None:
+    """Run contrast subcommand.
+
+    Args:
+        config (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)
+        contrast_image = ImageOps.autocontrast(
+            original_image, cutoff=args.cutoff
+        )
+
+        save_image(args, contrast_image, image_filename, "contrast")