imagesmacker 2.1.5__tar.gz

imagesmacker-2.1.5/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: imagesmacker
+Version: 2.1.5
+Summary: 
+Author: whinee
+Requires-Python: >=3.10,<3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: alltheutils (>=1.0.1,<2.0.0)
+Requires-Dist: msgpack (>=1.0.5,<2.0.0)
+Requires-Dist: openpyxl (>=3.1.2,<4.0.0)
+Requires-Dist: pillow (>=10.0.1,<11.0.0)
+Requires-Dist: pydantic (>=2.8.2,<3.0.0)
+Requires-Dist: python-barcode (>=0.15.1,<0.16.0)
+Requires-Dist: pyyaml (>=6.0,<7.0)
+Requires-Dist: qrcode[pil] (>=7.4.2,<8.0.0)
+Requires-Dist: regex (>=2023.8.8,<2024.0.0)
+Requires-Dist: rich (>=13.3.5,<14.0.0)

imagesmacker-2.1.5/imagesmacker/draw.py

@@ -0,0 +1,358 @@
+from textwrap import wrap
+from typing import Any, Literal
+
+from barcode import Code128
+from barcode.writer import ImageWriter as BarcodeImageWriter
+from PIL import Image, ImageDraw
+from qrcode.image.pil import PilImage
+from qrcode.main import QRCode
+
+from imagesmacker.fonts import FontSizeCalculator, font_loader
+from imagesmacker.models.coordinates import XYXY, RectangleCoordinates
+from imagesmacker.models.draw import Code128Config, QRCodeConfig, TextConfig
+from imagesmacker.models.fields import BarcodeFieldAttributes, TextFieldAttributes
+from imagesmacker.utils import scale_and_center_rect
+
+
+class Barcode:
+    @staticmethod
+    def code128(
+        data: str,
+        code_128_config: Code128Config,
+        field_coords: RectangleCoordinates,
+    ) -> PilImage:
+        if code_128_config.options is None:
+            code_128_config.options = {
+                "module_width": 0.2,
+                "module_height": 15,
+                "quiet_zone": 1,
+                "text_distance": 2,
+            }
+        barcode_class = Code128(data, writer=BarcodeImageWriter())
+
+        module_height = code_128_config.options.get("module_height", 15)
+        bc_width, bc_height = barcode_class.render(
+            writer_options=code_128_config.options,
+            text="",
+        ).size
+        field_width, field_height = field_coords.xywh()[2:4]
+
+        bc_aspect_ratio = bc_height / bc_width
+        field_aspect_ratio = field_height / field_width
+        bc_factor = module_height / bc_aspect_ratio
+
+        code_128_config.options["module_height"] = field_aspect_ratio * bc_factor
+
+        return barcode_class.render(writer_options=code_128_config.options, text="")
+
+    @staticmethod
+    def qr(
+        data: str,
+        qr_code_config: QRCodeConfig,
+        field_coords: RectangleCoordinates,
+    ) -> PilImage:
+        qr = QRCode(
+            border=qr_code_config.border,
+            box_size=qr_code_config.box_size,
+        )
+        qr.add_data(data)
+        qr.make(fit=True)
+        return qr.make_image(
+            # image_factory=StyledPilImage,
+            # module_drawer=RoundedModuleDrawer(),
+        )
+
+
+class Draw:
+    """
+    An abstraction of `ImageDraw.Draw` specifically for drawing texts
+    and barcodes in images.
+    """
+
+    def __init__(self, image: Image.Image) -> None:
+        self.image = image
+        self.draw = ImageDraw.Draw(image)
+
+    def text(  # noqa: C901
+        self,
+        text: str,
+        field_coords: RectangleCoordinates,
+        field_attributes: TextFieldAttributes,
+    ) -> None:
+        """
+        This method will try to fit the text within the field.
+
+        Args:
+        - text (`str`): Text to be drawn
+        - field_coords (`RectangleCoordinates`): _description_
+        - field_attributes (`FieldAttributes`): _description_
+        """
+
+        # If there is no text to draw, return immediately.
+        if (text is None) or (str(text).strip() == ""):
+            return
+
+        text_config = field_attributes.text_config
+
+        font_size = text_config.font_size
+        anchor = text_config.anchor
+        text_style = text_config.style
+
+        fsc = FontSizeCalculator(self.draw, text_config.font_filepath)
+
+        field_x1, field_y1, field_x2, field_y2 = field_coords.xyxy()
+        field_x, field_y, field_width, field_height = field_coords.xywh()
+
+        # If the text is multiline or is allowed to be broken into multiple lines, then
+        # we try to break it into multiple lines so that it can fit into the field
+        if ("\n" in text) or text_config.break_text:
+            font_size, text_lines_list, text_height = self.break_text(
+                text=text,
+                text_config=text_config,
+                font_size=font_size,
+                fsc=fsc,
+                field_width=field_width,
+                field_height=field_height,
+            )
+        # Else, we just try to fit a single line of text in the field
+        else:
+            while True:
+                text_width, text_height = fsc.get_text_bbox(font_size, text)
+                # If `text_width` is greater than `field_width` or if `text_height` is
+                # greater than `field_height`, then the `font_size` will be decremented
+                # by 1, and the loop will continue until the condition is no longer
+                # satisfied.
+                if (text_width > field_width) or (text_height > field_height):
+                    font_size -= 1
+                else:
+                    break
+
+        # If the text needs to be inverted (ie. turned upside down), then, it needs to
+        # undergo the following steps:
+        if text_config.inverted:
+            # I dont know why this code is here, so I just commented it out
+            # # Get the half of the text height, then round that
+            # halved_text_height = round(text_height / 2) # `hth` in short
+            # # Subtract `hth` to the `text_height` to get the larger half of the text
+            # # height. This is for pixel accuracy
+            # larger_hth = text_height - halved_text_height
+
+            # # field_height += text_height
+
+            # Create a new image with the same width and height as the field to draw the
+            # soon-to-be inverted text on
+            inverted_text_image = Image.new(
+                "RGBA",
+                (field_width, field_height),
+                color=(0, 0, 0, 0),
+            )
+            draw = ImageDraw.Draw(inverted_text_image)
+
+            horizontal_anchor, vertical_anchor = anchor  # type: ignore
+
+            # Reverse horizontal anchor
+            match horizontal_anchor:
+                case "l":
+                    horizontal_anchor = "r"
+                case "r":
+                    horizontal_anchor = "l"
+
+            # I DO NOT FUCKING UNDERSTAND WHY I NEED TO DO THIS
+            # edit: I don't care anymore
+            if not text_config.break_text:
+                match vertical_anchor:
+                    case "t":
+                        vertical_anchor = "b"
+                    case "b":
+                        vertical_anchor = "t"
+
+            anchor = horizontal_anchor + vertical_anchor
+        else:
+            draw = self.draw
+
+        draw_text_common_kwargs: dict[str, Any] = {
+            "font": font_loader(
+                text_config.font_filepath,
+                font_size,
+            ),
+            "anchor": anchor,
+            "fill": text_style.fill,
+        }
+
+        # If the text is multiline or is allowed to be broken into multiple lines, then
+        # we do the following:
+        if ("\n" in text) or text_config.break_text:
+            # We just approximate where to place the lines of text vertically.
+            # That's why there are overlaps in glyphs when the line height is set at 1.
+            # That's also why line height's default is set at `1.2`.
+            # If we don't approximate this, then we can have non-overlapping glyphs,
+            # but I have a deadline to meet, yknow?
+
+            # text_height over length of text_lines_list
+            tholtlt = text_height / len(text_lines_list)
+
+            # there is a `vertical_additive` to place the multiline text exactly where
+            # it is aligned to
+            match anchor[1]:
+                case "t":
+                    vertical_additive = (
+                        field_height - text_height if text_config.inverted else field_y
+                    )
+                case "m":
+                    vertical_additive = round(
+                        (field_height - text_height) / 2
+                        if text_config.inverted
+                        else field_y + ((field_height - text_height) / 2),
+                    )
+                case "b":
+                    vertical_additive = (
+                        0
+                        if text_config.inverted
+                        else field_y + field_height - text_height
+                    )
+
+            text_x = field_coords.text_coordinates(anchor=anchor)[0] # type: ignore
+
+            if text_config.inverted:
+                text_x =- field_x
+
+            draw_text_common_kwargs["anchor"] = anchor[0] + "m"
+
+            for text_line, text_y in zip(
+                text_lines_list,
+                range(round(tholtlt / 2), text_height, round(tholtlt)),
+                strict=True,
+            ):
+                text_xy = (text_x, vertical_additive + text_y)
+                draw.text(
+                    text=text_line,
+                    xy=text_xy,
+                    **draw_text_common_kwargs,
+                )
+
+                # # WARNING: remove in production
+                # text_width, text_height = fsc.get_text_bbox(font_size, text_line)
+                # rect_coordinates = (
+                #     text_xy[0] - (text_width / 2),
+                #     text_xy[1] - (text_height / 2),
+                #     text_xy[0] + (text_width / 2),
+                #     text_xy[1] + (text_height / 2),
+                # )
+                # self.draw.rectangle(
+                #     rect_coordinates,
+                #     outline="white",
+                #     width=1,
+                # )
+
+            # # WARNING: remove in production
+            # self.draw.rectangle(
+            #     field_coords.xyxy(),
+            #     outline="red",
+            #     width=1,
+            # )
+        else:
+            draw_field_coords: RectangleCoordinates
+            if text_config.inverted:
+                draw_field_coords = XYXY(0, 0, field_x2 - field_x1, field_y2 - field_y1)
+            else:
+                draw_field_coords = field_coords
+
+            draw.text(
+                text=text,
+                xy=draw_field_coords.text_coordinates(anchor=anchor),  # type: ignore
+                **draw_text_common_kwargs,
+            )
+
+        if text_config.inverted:
+            inverted_text_image = inverted_text_image.rotate(180)
+            self.image.paste(
+                inverted_text_image,
+                (field_x1, field_y1, field_x2, field_y2),
+                inverted_text_image,
+            )
+
+    def break_text(
+        self,
+        text: str,
+        text_config: TextConfig,
+        font_size: int,
+        fsc: FontSizeCalculator,
+        field_width: int,
+        field_height: int,
+    ) -> tuple[int, list[str], int]:
+        while True:
+            # Initialize variables
+            text_width = 0
+            text_line_width_list = []
+            text_line_height_list = []
+
+            text_lines_list = text.splitlines()  # tlt
+            # Count the number of characters in the longest line of the multiline text
+            max_char_length_in_tlt = max(len(i) for i in text_lines_list)
+
+            # We can deduce the number of characters that fit in the field width
+            # by multiplying the field width by `max_char_length_in_tlt`, all over the
+            # width of the text is when drawn on the image.
+            # This uses the fact that `(a/(b/c)) = ((a * c)/b)` to simplify the equation
+            characters_per_field_width = round(
+                (field_width * max_char_length_in_tlt)
+                / fsc.get_text_bbox(font_size, text)[0],
+            )
+
+            # Rewrite the `text_lines_list` to have the longest line of text be
+            # the value of `characters_per_field_width`
+            text_lines_list = [
+                j for i in text_lines_list for j in wrap(i, characters_per_field_width)
+            ]
+            length_tlt = len(text_lines_list)
+
+            # Measure the width and height of each line of text, then appened it
+            # to the intialized lists earlier
+            for text_line in text_lines_list:
+                text_line_width, text_line_height = fsc.get_text_bbox(
+                    font_size,
+                    text_line,
+                )
+                text_line_width_list.append(text_line_width)
+                text_line_height_list.append(text_line_height)
+
+                # set `text_width` to be the width of the widest line of text
+            text_width = max(text_line_width_list)
+
+            text_height = round(
+                length_tlt
+                * text_config.line_height
+                * (sum(text_line_height_list) / length_tlt),
+            )
+
+            # If `text_width` is greater than `field_width`, or if `text_height` is
+            # greater than `field_height`, then the `font_size` will be decremented
+            # by 1, and the loop will continue until the condition is no longer
+            # satisfied.
+            if (text_width > field_width) or (text_height > field_height):
+                font_size -= 1
+            else:
+                return (font_size, text_lines_list, text_height)
+
+    def barcode(
+        self,
+        data: str,
+        type: Literal["Code128", "QR"],
+        field_coords: RectangleCoordinates,
+        field_attributes: BarcodeFieldAttributes,
+    ) -> None:
+        # If there is no text to draw, return immediately.
+        if (data is None) or (str(data).strip() == ""):
+            return
+
+        barcode_config = field_attributes.barcode_config
+
+        barcode = getattr(Barcode, type.lower())(data, barcode_config, field_coords)
+
+        barcode_coords = scale_and_center_rect(field_coords, barcode.size)
+        barcode_wh = barcode_coords.xywh()[2:4]
+
+        self.image.paste(
+            barcode.resize(barcode_wh, Image.Resampling.LANCZOS),
+            barcode_coords.xyxy(),
+        )

imagesmacker-2.1.5/imagesmacker/fields.py

@@ -0,0 +1,77 @@
+# import multiprocessing.dummy as mp
+# import os
+# from typing import Any
+
+
+# from imagesmacker.draw import Draw
+from imagesmacker.models.coordinates import XYXY, RectangleCoordinates
+from imagesmacker.models.fields import (
+    FieldsCoords,
+    RelativeDataFieldFormat,
+)
+
+
+def relative_field_formatting(
+    data_field_format: RelativeDataFieldFormat,
+    dimensions: RectangleCoordinates,
+) -> FieldsCoords:
+    """
+    _summary_.
+
+    Args:
+        data_field_format (RelativeDataFieldFormat): _description_
+        dimensions (Coordinates): Coordinate mode agnostic dimensions.
+
+    Returns:
+        dict[str, tuple[float, float, float, float]]: _description_
+    """
+
+    initial_field_x, field_y, field_width, field_height = dimensions.xywh()
+
+    total_field_fractional_height: float = 0
+    ls_cell_fractional_widths: list[float] = []
+
+    for row in data_field_format.rows:
+        total_row_fractional_width: float = 0
+
+        row_fractional_height = row.fr
+        row_cells = row.cells
+
+        total_field_fractional_height += row_fractional_height
+
+        for cell in row_cells:
+            total_row_fractional_width += cell.fr
+
+        ls_cell_fractional_widths.append(total_row_fractional_width)
+
+    output: dict[str, XYXY] = {}
+
+    for row, total_row_fractional_width in zip(
+        data_field_format.rows,
+        ls_cell_fractional_widths,
+        strict=True,
+    ):
+        row_fractional_height = row.fr
+        row_cells = row.cells
+
+        row_height = round(
+            field_height * (row_fractional_height / total_field_fractional_height),
+        )
+
+        field_x = initial_field_x
+
+        for cell in row_cells:
+            cell_fractional_width = cell.fr
+            cell_width = round(
+                field_width * (cell_fractional_width / total_row_fractional_width),
+            )
+            output[cell.name] = XYXY(
+                field_x,
+                field_y,
+                field_x + cell_width,
+                field_y + row_height,
+            )
+            field_x += cell_width
+        field_y += row_height
+
+    return output

imagesmacker-2.1.5/imagesmacker/fonts.py

@@ -0,0 +1,49 @@
+import os
+
+from alltheutils.utils import file_exists
+from PIL import ImageDraw, ImageFont
+from PIL.ImageFont import FreeTypeFont
+
+
+def font_loader(
+    filepath: str,
+    size: int = 10,
+) -> FreeTypeFont:
+    filepath = os.path.abspath(filepath)
+    return ImageFont.truetype(file_exists(filepath), size)
+
+
+class FontSizeCalculator:
+    def __init__(
+        self,
+        draw: ImageDraw.ImageDraw,
+        font: str,
+    ) -> None:
+        """
+        Initialize the FontSizeCalculator class.
+
+        Args:
+        - draw (`ImageDraw.ImageDraw`): The ImageDraw object to use for text measurement.
+        - font (`str`): The font name or path to use.
+        - kwargs (`dict[str, Any]`): Additional keyword arguments.
+        """
+        self.draw = draw
+        self.font = font
+
+    def get_text_bbox(self, size: int, text: str) -> tuple[int, int]:
+        """
+        Get the width and height of the text for a given font size.
+
+        Args:
+        - size (`int`): The font size to measure.
+        - text (`str`): The text string to measure.
+
+        Returns:
+        `list[int]`: A list containing the width and height of the text.
+        """
+        x1, y1, x2, y2 = self.draw.multiline_textbbox(
+            xy=(0, 0),
+            text=text,
+            font=font_loader(self.font, size),
+        )
+        return (x2 - x1, y2 - y1)

imagesmacker-2.1.5/imagesmacker/models/coordinates.py

@@ -0,0 +1,130 @@
+import abc
+from collections.abc import Iterator
+from typing import NamedTuple, cast
+
+from imagesmacker.models.draw import TextAnchor, validate_text_anchor
+
+
+class XYXYNamedTuple(NamedTuple):
+    x1: int
+    y1: int
+    x2: int
+    y2: int
+
+
+class XYWHNamedTuple(NamedTuple):
+    x: int
+    y: int
+    w: int
+    h: int
+
+
+class RectangleCoordinates(metaclass=abc.ABCMeta):
+    """
+    Rectangle Coordinates.
+
+    You can have an `xyxy` or `xywh` mode coordinates and it can be read by any
+    methods that knows how to read `RectangleCoordinates`.
+
+    Args:
+        metaclass (_type_, optional): _description_. Defaults to abc.ABCMeta.
+    """
+
+    coords: NamedTuple
+
+    @abc.abstractmethod
+    def xyxy(self) -> XYXYNamedTuple:
+        pass
+
+    @abc.abstractmethod
+    def xywh(self) -> XYWHNamedTuple:
+        pass
+
+    def text_coordinates(self, anchor: TextAnchor = "mm") -> tuple[int, int]:
+        """
+        `RectangleCoordinates` is often used as.
+
+        Args:
+        - anchor (`TextAnchor`, optional): _description_. Defaults to `"mm"`.
+
+        Returns:
+        `tuple[int, int]`: _description_
+        """
+        validate_text_anchor(anchor)
+        x1, y1, x2, y2 = self.xyxy()
+        horizontal_anchor, vertical_anchor = anchor  # type: ignore
+
+        match horizontal_anchor:
+            case "l":
+                x = x1
+            case "m":
+                x = round((x1 + x2) / 2)
+            case "r":
+                x = x2
+
+        match vertical_anchor:
+            case "t":
+                y = y1
+            case "m":
+                y = round((y1 + y2) / 2)
+            case "b":
+                y = y2
+
+        return (x, y)
+
+    def __iter__(self) -> Iterator[int]:
+        return iter(self.coords)
+
+    def __str__(self) -> str:
+        return str(self.tuple())
+
+    def __repr__(self) -> str:
+        return repr(self.coords)
+
+    def list(self) -> list[int]:
+        return list(self.coords)
+
+    def tuple(self) -> tuple[int, int, int, int]:
+        return cast(tuple[int, int, int, int], tuple(self.coords))
+
+    def dict(self) -> dict[str, int]:
+        return self.coords._asdict()
+
+
+class XYXY(RectangleCoordinates):
+    def __init__(self, x1: int, y1: int, x2: int, y2: int) -> None:
+        self.coords = XYXYNamedTuple(x1=x1, y1=y1, x2=x2, y2=y2)
+
+    def xyxy(self) -> XYXYNamedTuple:
+        return cast(XYXYNamedTuple, self.coords)
+
+    def xywh(self) -> XYWHNamedTuple:
+        """
+        Convert `XYXYNamedTuple` to `XYWHNamedTuple`.
+
+        Returns:
+        `XYWHNamedTuple`
+        """
+
+        x1, y1, x2, y2 = self.coords
+        return XYWHNamedTuple(x=x1, y=y1, w=x2 - x1, h=y2 - y1)
+
+
+class XYWH(RectangleCoordinates):
+    def __init__(self, x: int, y: int, w: int, h: int) -> None:
+        self.coords = XYWHNamedTuple(x=x, y=y, w=w, h=h)
+
+    def xyxy(self) -> XYXYNamedTuple:
+        """
+        Convert `XYWHNamedTuple` to `XYXYNamedTuple`.
+
+        Returns:
+        `XYXYNamedTuple`
+        """
+
+        x, y, w, h = self.coords
+
+        return XYXYNamedTuple(x1=x, y1=y, x2=x + w, y2=y + h)
+
+    def xywh(self) -> XYWHNamedTuple:
+        return cast(XYWHNamedTuple, self.coords)

imagesmacker-2.1.5/imagesmacker/models/draw.py

@@ -0,0 +1,55 @@
+from typing import Any, Literal, Optional, TypeAlias
+
+from PIL.ImageDraw import _Ink
+from pydantic import BaseModel, ConfigDict
+
+TextAnchor: TypeAlias = Literal["lt", "mt", "rt", "lm", "mm", "rm", "lb", "mb", "rb"]
+
+
+class TextStyle(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    fill: _Ink = "#000"
+    italics: bool = False  # not in use
+    underline: bool = False  # not in use
+
+
+class TextConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    font_filepath: str
+    font_size: int = 100
+    anchor: TextAnchor = "mm"
+    break_text: bool = False
+    line_height: float | int = 1.2
+    inverted: bool = False
+    style: TextStyle = TextStyle()
+
+
+class BarcodeConfig(BaseModel):
+    pass
+
+
+class Code128Config(BarcodeConfig):
+    model_config = ConfigDict(extra="forbid")
+    options: Optional[dict[str, Any]] = None
+
+
+class QRCodeConfig(BarcodeConfig):
+    model_config = ConfigDict(extra="forbid")
+    box_size: int = 20
+    border: int = 1
+
+
+def validate_text_anchor(anchor: str):
+    if len(anchor) != 2:
+        raise ValueError("The string must be exactly 2 characters long.")
+
+    anchor_tuple: tuple[str, str] = tuple(anchor)  # type: ignore
+    horizontal_anchor, vertical_anchor = anchor_tuple  # type: ignore[misc]
+    if horizontal_anchor not in {"l", "m", "r"}:
+        raise ValueError(
+            "The horizontal anchor must be one of the following: 'l', 'm', or 'r'.",
+        )
+    if vertical_anchor not in {"t", "m", "b"}:
+        raise ValueError(
+            "The vertical anchor must be one of the following: 't', 'm', or 'b'.",
+        )

imagesmacker-2.1.5/imagesmacker/models/fields.py

@@ -0,0 +1,43 @@
+from typing import TypeAlias
+
+from pydantic import BaseModel, ConfigDict
+
+from imagesmacker.models.coordinates import XYXY
+from imagesmacker.models.draw import BarcodeConfig, TextConfig
+
+
+class RelativeFieldCell(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    fr: float
+    name: str
+
+
+class RelativeRow(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    fr: float
+    cells: list[RelativeFieldCell]
+
+
+class RelativeDataFieldFormat(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    rows: list[RelativeRow]
+
+
+class FieldAttributes(BaseModel):
+    pass
+
+
+class TextFieldAttributes(FieldAttributes):
+    model_config = ConfigDict(extra="forbid")
+    text_config: TextConfig
+
+
+class BarcodeFieldAttributes(FieldAttributes):
+    model_config = ConfigDict(extra="forbid")
+    barcode_config: BarcodeConfig
+
+
+FieldsCoords: TypeAlias = dict[str, XYXY]
+FieldsConfig: TypeAlias = (
+    dict[str, TextFieldAttributes] | dict[str, BarcodeFieldAttributes]
+)

imagesmacker-2.1.5/imagesmacker/utils.py

@@ -0,0 +1,44 @@
+from imagesmacker.models.coordinates import XYXY, RectangleCoordinates
+
+
+def rect_coords_middle_point(
+    coordinates: RectangleCoordinates,
+) -> tuple[int, float]:
+    x1, y1, x2, y2 = coordinates.xyxy()
+    return (x2 - x1, y2 - y1)
+
+
+def scale_and_center_rect(
+    br_coords: RectangleCoordinates,
+    sr_wh: tuple[int, int],
+) -> XYXY:
+    """
+    Given a big rectangle's xyxy and small rectangle's width and height, fit and center the small rectangle in the big rectangle, retaining the small rectangle's aspect ratio. Then, return the xyxy for the small rectangle to make that happen.
+
+    Args:
+    - br_xyxy (tuple[int, int, int, int]): Big rectangle's xyxy.
+    - sr_wh (tuple[int, int]): Small rectangle's width and height.
+
+    Returns:
+        XYXY: Resulting xyxy.
+    """
+    br_x1, br_y1, br_x2, br_y2 = br_coords.xyxy()
+    br_w = br_x2 - br_x1
+    br_h = br_y2 - br_y1
+
+    sr_w, sr_h = sr_wh
+
+    scale_w = br_w / sr_w
+    scale_h = br_h / sr_h
+
+    scale = min(scale_w, scale_h)
+
+    scaled_sr_w = int(sr_w * scale)
+    scaled_sr_h = int(sr_h * scale)
+
+    new_x1 = br_x1 + (br_w - scaled_sr_w) // 2
+    new_y1 = br_y1 + (br_h - scaled_sr_h) // 2
+    new_x2 = new_x1 + scaled_sr_w
+    new_y2 = new_y1 + scaled_sr_h
+
+    return XYXY(new_x1, new_y1, new_x2, new_y2)

imagesmacker-2.1.5/pyproject.toml

@@ -0,0 +1,169 @@
+[tool.poetry]
+name = "imagesmacker"
+version = "2.1.5"
+description = ""
+authors = ["whinee"]
+
+packages = [
+    { include = "imagesmacker" }
+]
+
+[tool.poetry.dependencies]
+python = ">=3.10,<3.13"
+rich = "^13.3.5"
+msgpack = "^1.0.5"
+openpyxl = "^3.1.2"
+pyyaml = "^6.0"
+regex = "^2023.8.8"
+pillow = "^10.0.1"
+qrcode = {extras = ["pil"], version = "^7.4.2"}
+pydantic = "^2.8.2"
+python-barcode = "^0.15.1"
+alltheutils = "^1.0.1"
+
+[tool.poetry.group.dev]
+optional = true
+
+[tool.poetry.group.dev.dependencies]
+black = "^23.3.0"
+mypy = "^1.1.1"
+no-implicit-optional = "^1.3"
+ruff = "^0.0.291"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.mypy]
+disable_error_code = [
+    "import",
+    "annotation-unchecked",
+    "attr-defined",
+    "no-untyped-call",
+    "no-untyped-def",
+    "type-arg",
+    "unused-ignore",
+]
+strict = true
+exclude = "dev"
+
+[tool.ruff.per-file-ignores]
+"examples/*" = [
+    "INP001",
+    "N999"
+]
+
+[tool.ruff]
+select = [
+    "ANN",
+    "B",
+    "BLE",
+    "C4",
+    "C90",
+    "COM",
+    "D",
+    # "DTZ",
+    "E",
+    "F",
+    "I",
+    "INP",
+    "N",
+    "PIE",
+    "Q",
+    "RET",
+    "RSE",
+    "RUF",
+    "S",
+    "UP"
+]
+
+# Allow autofix for all enabled rules (when `--fix`) is provided.
+fixable = [
+    "ANN",
+    "B",
+    "C4",
+    "COM",
+    "D",
+    "E",
+    "F",
+    "I",
+    "PIE",
+    "Q",
+    "RET",
+    "RSE",
+    "RUF",
+    "UP"
+]
+unfixable = []
+
+ignore = [
+    "ANN001",
+    "ANN002",
+    "ANN003",
+    "ANN101",
+    "ANN201",
+    "ANN202",
+    "ANN401",
+    "B008",
+    "D100",
+    "D101",
+    "D102",
+    "D103",
+    "D104",
+    "D105",
+    "D106",
+    "D107",
+    "D202",
+    "D203",
+    "D205",
+    "D212",
+    "D401",
+    "D404",
+    "D406",
+    "D407",
+    "D417",
+    "E501",
+    "F722",
+    "I002",
+    "N812",
+    "N818",
+    "Q000",
+    "RET503",
+    "S101",
+    "UP007",
+    "UP032",
+]
+
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "pyenv",
+    "venv",
+]
+
+line-length = 88
+
+target-version = "py310"
+
+[tool.ruff.mccabe]
+max-complexity = 5
+
+[tool.ruff.pycodestyle]
+ignore-overlong-task-comments = false