dankcli-lib 0.5.9__py3-none-any.whl

dankcli_lib/__main__.py

@@ -0,0 +1,117 @@
+import os
+import sys
+import argparse
+import datetime
+from .caption import Caption
+
+
+def get_file_name():
+    """Generate timestamp-based filename."""
+    return datetime.datetime.now().strftime("%Y%m%d%H%M%S")
+
+
+def parse_color(color_str):
+    """Parse color string in format R,G,B or R G B."""
+    if not color_str:
+        return None
+    
+    # Try comma-separated first
+    if ',' in color_str:
+        try:
+            r, g, b = map(int, color_str.split(','))
+            return (r, g, b)
+        except ValueError:
+            pass
+    
+    # Try space-separated
+    try:
+        r, g, b = map(int, color_str.split())
+        return (r, g, b)
+    except ValueError:
+        raise ValueError(f"Invalid color format. Use R,G,B or R G B (e.g., '255,255,255')")
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="dankcli_lib", description="Add captions to images with various styling options")
+    
+    # Required arguments
+    parser.add_argument("img", help="Path to the source image")
+    parser.add_argument("text", help="Text to caption (use \\n for new lines)")
+    
+    # Output options
+    parser.add_argument("-f", "--filename", help="Custom output filename (without extension)")
+    
+    # Font options
+    parser.add_argument("--font", default="arial.ttf", help="Path to font file (default: arial.ttf)")
+    
+    # Top text options
+    parser.add_argument("--top_font_color", help="Top text color as R,G,B or R G B (e.g., '0,0,0' for black)")
+    parser.add_argument("--top_bg_color", help="Top background color as R,G,B or R G B (e.g., '255,255,255' for white)")
+    
+    # Bottom text options
+    parser.add_argument("--bottom_text", help="Text to place at the bottom of the image")
+    parser.add_argument("--bottom_text_box", action="store_true", default=True,
+                        help="Add white box for bottom text (default: True)")
+    parser.add_argument("--no-bottom-text-box", dest="bottom_text_box", action="store_false",
+                        help="Overlay bottom text directly on image without box")
+    parser.add_argument("--bottom_font_color", help="Bottom text color as R,G,B or R G B (e.g., '255,255,255' for white)")
+    parser.add_argument("--bottom_bg_color", help="Bottom background color as R,G,B or R G B (e.g., '255,255,255' for white)")
+    
+    # Separator line options
+    parser.add_argument("--separator_line", action="store_true", 
+                        help="Draw a line separating the caption from the image")
+    parser.add_argument("--separator_color", default="0,0,0",
+                        help="Separator line color as R,G,B or R G B (default: '0,0,0' for black)")
+    
+    args = parser.parse_args()
+
+    # Resolve image path
+    img_path = os.path.abspath(os.path.expanduser(args.img))
+    
+    # Check if image exists
+    if not os.path.exists(img_path):
+        print(f"Error: Image file not found: {img_path}")
+        sys.exit(1)
+    
+    try:
+        # Parse color arguments
+        top_font_color = parse_color(args.top_font_color) if args.top_font_color else None
+        top_bg_color = parse_color(args.top_bg_color) if args.top_bg_color else None
+        bottom_font_color = parse_color(args.bottom_font_color) if args.bottom_font_color else None
+        bottom_bg_color = parse_color(args.bottom_bg_color) if args.bottom_bg_color else None
+        separator_color = parse_color(args.separator_color)
+        
+        # Create Caption instance with all options
+        caption = Caption(
+            img_path, 
+            args.text, 
+            font_path=args.font, 
+            separator_line=args.separator_line,
+            separator_line_color=separator_color,
+            bottom_text=args.bottom_text,
+            bottom_text_box=args.bottom_text_box,
+            top_font_color=top_font_color,
+            bottom_font_color=bottom_font_color,
+            top_background_color=top_bg_color,
+            bottom_background_color=bottom_bg_color
+        )
+        
+        # Determine output filename and extension
+        out_name = args.filename if args.filename else get_file_name()
+        # Check if image has transparency or if we're using overlay text (no box)
+        # PNG supports transparency better, but we'll let the user specify format eventually
+        is_jpeg = img_path.lower().endswith(('.jpg', '.jpeg'))
+        extension = "jpg" if is_jpeg else "png"
+        output_path = f"{out_name}.{extension}"
+        
+        # Generate and save
+        caption.save(output_path)
+        print(f"Meme saved successfully: {output_path}")
+        
+    except Exception as e:
+        print(f"Error: Could not process image. {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

dankcli_lib/caption.py

@@ -0,0 +1,251 @@
+from PIL import Image, ImageFont, ImageDraw
+import math, io
+
+class Caption:
+    """Handles image captioning with text overlay."""
+    
+    # Default styling constants
+    TOP_PADDING = 10
+    BOTTOM_PADDING = 10
+    WIDTH_PADDING = 10
+    MINIMUM_FONT_SIZE = 13
+    HW_ASPECT_RATIO_THRESHOLD = 1.666
+    MAX_BOTTOM_TEXT_HEIGHT_RATIO = 0.334
+    
+    def __init__(self, image_path, text, font_path="arial.ttf", separator_line=False, separator_line_color=None, 
+                 bottom_text=None, bottom_text_box=True,
+                 top_font_color=None, bottom_font_color=None, top_background_color=None, bottom_background_color=None):
+        """
+        Initialize Caption with an image and text.
+        
+        Args:
+            image_path: Path to the source image
+            text: Caption text (supports \\n for newlines)
+            font_path: Path to font file (defaults to arial.ttf)
+            separator_line: Whether to draw a black line between text and image
+            bottom_text: Optional text to place at the bottom of the image
+            bottom_text_box: If True, adds white box for bottom text. If False, overlays text on image
+            top_font_color: Font color for top text (defaults to black (0,0,0) if None)
+            bottom_font_color: Font color for bottom text (defaults to white (255,255,255) if None)
+        """
+        self.image = Image.open(image_path)
+        self.text = text.replace("\\n", "\n")
+        self.bottom_text = bottom_text.replace("\\n", "\n") if bottom_text else None
+        self.bottom_text_box = bottom_text_box 
+        self.font_path = font_path
+        self.separator_line = separator_line
+        self.separator_line_color = separator_line_color if separator_line_color is not None else (0, 0, 0)
+
+        self.width, self.height = self.image.size
+        
+        # Set default colors if not provided
+        self.top_font_color = top_font_color if top_font_color is not None else (0, 0, 0)
+        self.bottom_font_color = bottom_font_color if bottom_font_color is not None else (0, 0, 0)
+        
+        self.top_background_color = top_background_color if top_background_color is not None else (255, 255, 255)
+        self.bottom_background_color = bottom_background_color if bottom_background_color is not None else (255, 255, 255)
+        
+        # Initialize font
+        try:
+            font_size = self._calculate_font_size()
+            self.font = ImageFont.truetype(font_path, size=font_size)
+        except OSError:
+            self.font = ImageFont.load_default()
+    
+    def _calculate_font_size(self):
+        """Calculate appropriate font size based on image dimensions."""
+        temp_size = max(math.floor(self.height / 13), self.MINIMUM_FONT_SIZE)
+        
+        # Scale down for very tall images
+        if self.height / self.width >= self.HW_ASPECT_RATIO_THRESHOLD:
+            return math.floor(temp_size / 1.5)
+        return temp_size
+    
+    def _get_text_dimensions(self, text):
+        """Get width and height of text with current font."""
+        bbox = self.font.getbbox(text)
+        return bbox[2] - bbox[0], bbox[3] - bbox[1]
+    
+    def _wrap_text(self, text, max_width):
+        """Wrap text to fit within max_width."""
+        lines = []
+        words = text.split(' ')
+        i = 0
+        
+        while i < len(words):
+            line = ''
+            while (i < len(words) and 
+                   self._get_text_dimensions(line + words[i])[0] < max_width - self.WIDTH_PADDING):
+                line = line + words[i] + " "
+                i += 1
+            
+            if not line:
+                line = words[i]
+                i += 1
+            
+            lines.append(line.strip())
+        
+        return '\n'.join(lines)
+    
+    def _process_text(self):
+        """Process and wrap text for rendering."""
+        wrapped_lines = "\n".join([
+            self._wrap_text(line, self.width) 
+            for line in self.text.split("\n")
+        ])
+        return wrapped_lines
+    
+    def _calculate_text_height(self, text):
+        """Calculate total height needed for text."""
+        line_list = text.split('\n')
+        if not line_list:
+            return 0
+        
+        _, line_height = self._get_text_dimensions(line_list[0])
+        total_text_height = len(line_list) * (line_height * 1.2)
+        return int(total_text_height + self.TOP_PADDING + self.BOTTOM_PADDING)
+    
+    def _get_text_position(self, text):
+        """Calculate top-left corner position for centered text."""
+        line_list = text.split('\n')
+        max_w = max(self._get_text_dimensions(line)[0] for line in line_list)
+        return ((self.width - max_w) / 2, self.TOP_PADDING)
+    
+    def _get_text_position_bottom(self, text, y_offset):
+        """Calculate top-left corner position for centered bottom text."""
+        line_list = text.split('\n')
+        max_w = max(self._get_text_dimensions(line)[0] for line in line_list)
+        return ((self.width - max_w) / 2, y_offset + self.TOP_PADDING)
+    
+    def _get_text_position_bottom_overlay(self, text):
+        """Calculate position for bottom text overlay on the image."""
+        line_list = text.split('\n')
+        max_w = max(self._get_text_dimensions(line)[0] for line in line_list)
+        
+        _, line_height = self._get_text_dimensions(line_list[0])
+        total_text_height = len(line_list) * (line_height * 1.2)
+        
+        y_position = self.height - total_text_height - self.BOTTOM_PADDING
+        
+        if y_position < self.TOP_PADDING:
+            y_position = self.TOP_PADDING
+            
+        return ((self.width - max_w) / 2, y_position)
+    
+    def generate(self):
+        """
+        Generate the captioned image.
+        
+        Returns:
+            PIL.Image: The captioned image
+        """
+        wrapped_top_text = self._process_text()
+        top_text_height = self._calculate_text_height(wrapped_top_text)
+        
+        bottom_text_height = 0
+        wrapped_bottom_text = None
+        if self.bottom_text:
+            wrapped_bottom_text = "\n".join([
+                self._wrap_text(line, self.width) 
+                for line in self.bottom_text.split("\n")
+            ])
+            bottom_text_height = self._calculate_text_height(wrapped_bottom_text)
+            
+            if self.bottom_text_box:
+                max_allowed_height = int(self.height * self.MAX_BOTTOM_TEXT_HEIGHT_RATIO)
+                if bottom_text_height > max_allowed_height:
+                    pass
+        
+        if self.bottom_text_box or not self.bottom_text:
+            total_height = top_text_height + self.height + bottom_text_height
+            canvas = Image.new("RGB", (self.width, total_height), (255, 255, 255))
+            canvas.paste(self.image, (0, top_text_height))
+        else:
+            total_height = top_text_height + self.height
+            canvas = Image.new("RGB", (self.width, total_height), (255, 255, 255))
+            canvas.paste(self.image, (0, top_text_height))
+        
+        draw = ImageDraw.Draw(canvas)
+        
+        if self.top_background_color:
+            draw.rectangle(
+                [(0, 0), (self.width, top_text_height)],
+                fill=self.top_background_color
+            )
+        
+        if self.separator_line:
+            line_y = top_text_height - 1
+            draw.line([(0, line_y), (self.width, line_y)], fill=self.separator_line_color, width=2)
+        
+        top_text_pos = self._get_text_position(wrapped_top_text)
+        
+        draw.multiline_text(
+            top_text_pos,
+            wrapped_top_text,
+            fill=self.top_font_color,
+            font=self.font,
+            align="center",
+            spacing=4
+        )
+        
+        if self.bottom_text and wrapped_bottom_text:
+            if self.bottom_text_box:
+                # Draw bottom background if specified
+                if self.bottom_background_color:
+                    bottom_bg_y = top_text_height + self.height
+                    draw.rectangle(
+                        [(0, bottom_bg_y), (self.width, bottom_bg_y + bottom_text_height)],
+                        fill=self.bottom_background_color
+                    )
+                
+                bottom_text_pos = self._get_text_position_bottom(wrapped_bottom_text, top_text_height + self.height)
+                
+                draw.multiline_text(
+                    bottom_text_pos,
+                    wrapped_bottom_text,
+                    fill=self.bottom_font_color,
+                    font=self.font,
+                    align="center",
+                    spacing=4
+                )
+                
+                if self.separator_line:
+                    line_y = top_text_height + self.height
+                    draw.line([(0, line_y), (self.width, line_y)], fill=self.separator_line_color, width=2)
+            else:
+                overlay_text_pos = self._get_text_position_bottom_overlay(wrapped_bottom_text)
+                adjusted_y = overlay_text_pos[1] + top_text_height
+                
+                draw.multiline_text(
+                    (overlay_text_pos[0], adjusted_y),
+                    wrapped_bottom_text,
+                    fill=self.bottom_font_color,
+                    font=self.font,
+                    align="center",
+                    spacing=4
+                )
+        
+        return canvas
+
+    def to_buffer(self, format="JPEG"):
+        captioned_image = self.generate()
+        buffer = io.BytesIO()
+        captioned_image.save(buffer, format=format)
+        buffer.seek(0)
+        return buffer
+
+    def close(self):
+        """Close the underlying PIL Image to free memory."""
+        if hasattr(self, 'image'):
+            self.image.close()
+
+    def save(self, output_path):
+        """
+        Generate and save the captioned image.
+        
+        Args:
+            output_path: Path to save the output image
+        """
+        captioned_image = self.generate()
+        captioned_image.save(output_path)
+        return output_path

dankcli_lib/functions.py

@@ -0,0 +1,54 @@
+from PIL import Image, ImageFont, ImageDraw
+import math
+import datetime
+
+TOP_PADDING = 10
+BOTTOM_PADDING = 10
+MINIMUM_FONT_SIZE = 13
+HW_ASPECT_RATIO_THRESHOLD = 1.666
+WIDTH_PADDING = 10 
+
+def get_font_size(img):
+    width, height = img.size
+    temp_size = max(math.floor(height / 13), MINIMUM_FONT_SIZE)
+    # Scale down for very tall images to prevent text from taking over
+    if height / width >= HW_ASPECT_RATIO_THRESHOLD:
+        return math.floor(temp_size / 1.5)
+    return temp_size
+
+def get_text_dimensions(text, font):
+    # Modern way to get text width/height in Pillow 10+
+    bbox = font.getbbox(text)
+    return bbox[2] - bbox[0], bbox[3] - bbox[1]
+
+def get_top_left_corner(lines, font, img_width):
+    line_list = lines.split('\n')
+    # Find width of the widest line for centering
+    max_w = max(get_text_dimensions(line, font)[0] for line in line_list)
+    return ((img_width - max_w) / 2, TOP_PADDING)
+
+def text_wrap(text, font, max_width):
+    lines = []
+    words = text.split(' ')
+    i = 0
+    while i < len(words):
+        line = ''
+        while i < len(words) and get_text_dimensions(line + words[i], font)[0] < max_width - WIDTH_PADDING:
+            line = line + words[i] + " "
+            i += 1
+        if not line:
+            line = words[i]
+            i += 1
+        lines.append(line.strip())
+    return '\n'.join(lines)
+
+def get_white_space_height(lines, font):
+    line_list = lines.split('\n')
+    if not line_list: return 0
+    _, line_height = get_text_dimensions(line_list[0], font)
+    # Add spacing between lines (roughly 20% of line height)
+    total_text_height = len(line_list) * (line_height * 1.2)
+    return int(total_text_height + TOP_PADDING + BOTTOM_PADDING)
+
+def get_file_name():
+    return datetime.datetime.now().strftime("%Y%m%d%H%M%S")

dankcli_lib-0.5.9.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: dankcli_lib
+Version: 0.5.9
+Summary: Patched CLI Meme Generator/Caption Maker to automatically add whitespace and text to top and bottom
+Home-page: https://github.com/TheMrRedSlime/dankcli
+Author: TheMrRedSlime
+License: MIT
+Keywords: dankcli dank meme memegenerator memes generator pillow dankmemes dankcli-lib caption maker make
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pillow
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+dankcli-lib is a CLI Image Captioning Tool, Meme Generator and Library which automatically adds white space and text to the top of your image.
+
+## Installation
+
+```bash
+$ pip install dankcli-lib
+```
+
+## Usage
+
+```bash
+$ python -m dankcli_lib "path/to/image" "Meme text you want to add" [-f "final_image_name_without_extension"]
+```
+
+#### Python:
+
+```python
+from dankcli_lib.caption import Caption
+
+caption = Caption("/path/to/image", "Text here", bottom_text="Bottom text here", bottom_font_color="#000000", bottom_text_box=False, font_path="arial.ttf", separator_line=True, separator_line_color="#000000", top_font_color="#ffffff", top_background_color="#000000", bottom_background_color="#000000")
+caption.save('file.jpg')
+```
+
+```python
+from dankcli_lib.caption import Caption
+
+with Caption("image.jpg", "Your text") as caption:
+    buffer = caption.to_buffer()
+    await ctx.send(file=discord.File(buffer, "image.jpg"))
+```
+
+```python
+from dankcli_lib.caption import Caption
+import discord
+
+caption = Caption("image.jpg", "Your text")
+buffer = caption.to_buffer()
+await ctx.send(file=discord.File(buffer, "image.jpg"))
+caption.close()
+```
+
+
+The text gets automatically wrapped according to width of image but you can also have intentional \n in your text.
+The image is saved in the current folder with the name as the current date and time, the name can be changed with the optional `-f` or `--filename` argument, specifying a file name without the file extension. 
+
+## Example
+
+#### Example 1 (showing \n functionality)
+```bash
+$ python -m dankcli_lib "templates/yesbutno.jpg" "Mom at 2am: Are you awake?\n\nMe:"
+```
+turns this
+
+![](https://i.imgur.com/nW3XPkF.jpg)
+
+to this
+
+![](https://i.imgur.com/h6qgp9m.png)
+
+#### Example 2 (showing auto textwrap)
+```bash
+$ python -m dankcli_lib "mymemes/helpmeme.jpg" "When you make a meme generator but now you can't stop making memes"
+```
+turns this
+
+![](https://i.imgur.com/6CDBFwF.jpg)
+
+to this
+
+![](https://i.imgur.com/lSBUfNb.png)
+

dankcli_lib-0.5.9.dist-info/RECORD

@@ -0,0 +1,11 @@
+dankcli_lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dankcli_lib/__main__.py,sha256=vjc_DYzlVldMyuMao9pSsY0FhZgr_rDnH-QFs3o4X48,4679
+dankcli_lib/caption.py,sha256=Gw-AJH-f8ZmJZ1jEMlNCJBHSbeYbQKYOyGksBu0YcYc,10039
+dankcli_lib/functions.py,sha256=4xJLgt7J7wwHXx9PU8JTHtrYW26cxMC7ofYe2hLeCVQ,1793
+dankcli_lib/fonts/HelveticaNeue.ttf,sha256=pRE5x00eO2aslstBe4I4pMoYZBvUUORPEEupmgFrhXw,104904
+dankcli_lib/fonts/arial.ttf,sha256=gq-zXto6Uu2xAQa8wEr5NkY4RCHe1TjTh5LBRE2BYCI,311636
+dankcli_lib-0.5.9.dist-info/licenses/LICENSE,sha256=36P6BuE6u6jk5eDjRVlsLsuQFHxGfWagG5XT404gTWs,1070
+dankcli_lib-0.5.9.dist-info/METADATA,sha256=ICts1RAaHpg2HVGvYsMJljMeWXI1tKpzXNKkfZTpeKQ,2612
+dankcli_lib-0.5.9.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+dankcli_lib-0.5.9.dist-info/top_level.txt,sha256=e9vV6O1assbgm4G3QNDYCMpIhhTpjYxnknp5RNhfFG4,12
+dankcli_lib-0.5.9.dist-info/RECORD,,

dankcli_lib-0.5.9.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dankcli_lib-0.5.9.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Shreyas Gupta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dankcli_lib-0.5.9.dist-info/top_level.txt

@@ -0,0 +1 @@
+dankcli_lib