alphapil 0.1.0__tar.gz

alphapil-0.1.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: alphapil
+Version: 0.1.0
+Summary: An asynchronous, template-based image generation engine
+Author-email: AlphaPIL Team <team@alphapil.dev>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/MeraLabs/AlphaPIL
+Project-URL: Repository, https://github.com/MeraLabs/AlphaPIL
+Project-URL: Documentation, https://alphapil.readthedocs.io
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: Pillow>=9.0.0
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: discord.py>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: isort>=5.10.0; extra == "dev"
+
+# AlphaPIL
+
+### About
+**AlphaPIL** is an asynchronous, template-based image generation engine built on top of Pillow (PIL). It is designed to make it easy to build dynamic images using a simple, readable template language.
+
+It is open-source and free to use, providing a powerful recursive parser for handling nested functions in image generation templates, with full support for asynchronous operations.
+
+AlphaPIL is suitable for developers building Discord bots, automated social media graphics, or any application requiring high-performance, template-driven image creation. This package is proudly maintained by the **[MeraLabs](https://github.com/MeraLabs)** organization.
+
+### Features
+- **60+ Pre-built Functions**: AlphaPIL comes packed with over 60 pre-built functions for shapes, text manipulation, image filtering, and masking.
+- **Asynchronous by Design**: Built from the ground up to support `asyncio`, making it perfect for modern web frameworks and Discord bots.
+- **Powerful DSL**: Use a simple `$function[arg1;arg2]` syntax to define your images. Supports nested functions like `$drawText[$toUpper[hello];10;10]`.
+- **Advanced Text Rendering**: Support for text gradients, strokes, automatic wrapping, and auto-sizing.
+- **Layer & Masking System**: Create complex compositions with multi-layer support and alpha masking.
+- **Image Caching**: Built-in caching for remote images to ensure fast rendering during repeated operations.
+
+### Setup
+Install AlphaPIL via pip:
+```bash
+pip install alphapil
+```
+
+Basic usage in your Python project:
+```python
+import asyncio
+from alphapil import CanvasEngine
+
+async def main():
+    engine = CanvasEngine()
+    
+    template = """
+    $createCanvas[800;400;#1a1a1a]
+    $setColor[#ffffff]
+    $setFont[Arial;40]
+    $drawText[Hello from AlphaPIL!;50;50]
+    $save[output.png]
+    """
+    
+    await engine.render_template(template)
+    print("Image generated successfully!")
+
+asyncio.run(main())
+```
+
+### Rendering with Data
+You can inject dynamic data into your templates easily:
+
+```python
+data = {
+    "username": "Alex",
+    "score": "950"
+}
+
+template = """
+$createCanvas[500;200;white]
+$setColor[black]
+$setFont[Roboto;30]
+$drawText[User: {username};20;20]
+$drawText[Score: {score};20;60]
+"""
+
+image_bytes = await engine.render_template(template, data=data)
+```
+
+### Advanced Masking
+AlphaPIL supports complex masking for creating avatars or stylized images:
+
+```python
+template = """
+$createCanvas[400;400;transparent]
+$createLayer[mask]
+$drawCircle[200;200;180;white]
+$switchLayer[main]
+$drawImage[https://example.com/avatar.png;0;0;400;400]
+$applyMask[mask]
+"""
+```
+
+### Support
+Need help? Join our official Discord community for support and updates!
+**[Join MeraLabs Discord](https://discord.gg/AXbuM6aaeQ)**
+
+### Contributing
+Refer to the [Contribution Documentation](https://github.com/MeraLabs/AlphaPIL/blob/main/CONTRIBUTING.md) for more information.
+
+### Keywords
+`alphapil` `image-generation` `pillow` `python` `async` `discord-bot` `template-engine` `meralabs` `canvas` `dsl`

alphapil-0.1.0/README.md

@@ -0,0 +1,88 @@
+# AlphaPIL
+
+### About
+**AlphaPIL** is an asynchronous, template-based image generation engine built on top of Pillow (PIL). It is designed to make it easy to build dynamic images using a simple, readable template language.
+
+It is open-source and free to use, providing a powerful recursive parser for handling nested functions in image generation templates, with full support for asynchronous operations.
+
+AlphaPIL is suitable for developers building Discord bots, automated social media graphics, or any application requiring high-performance, template-driven image creation. This package is proudly maintained by the **[MeraLabs](https://github.com/MeraLabs)** organization.
+
+### Features
+- **60+ Pre-built Functions**: AlphaPIL comes packed with over 60 pre-built functions for shapes, text manipulation, image filtering, and masking.
+- **Asynchronous by Design**: Built from the ground up to support `asyncio`, making it perfect for modern web frameworks and Discord bots.
+- **Powerful DSL**: Use a simple `$function[arg1;arg2]` syntax to define your images. Supports nested functions like `$drawText[$toUpper[hello];10;10]`.
+- **Advanced Text Rendering**: Support for text gradients, strokes, automatic wrapping, and auto-sizing.
+- **Layer & Masking System**: Create complex compositions with multi-layer support and alpha masking.
+- **Image Caching**: Built-in caching for remote images to ensure fast rendering during repeated operations.
+
+### Setup
+Install AlphaPIL via pip:
+```bash
+pip install alphapil
+```
+
+Basic usage in your Python project:
+```python
+import asyncio
+from alphapil import CanvasEngine
+
+async def main():
+    engine = CanvasEngine()
+    
+    template = """
+    $createCanvas[800;400;#1a1a1a]
+    $setColor[#ffffff]
+    $setFont[Arial;40]
+    $drawText[Hello from AlphaPIL!;50;50]
+    $save[output.png]
+    """
+    
+    await engine.render_template(template)
+    print("Image generated successfully!")
+
+asyncio.run(main())
+```
+
+### Rendering with Data
+You can inject dynamic data into your templates easily:
+
+```python
+data = {
+    "username": "Alex",
+    "score": "950"
+}
+
+template = """
+$createCanvas[500;200;white]
+$setColor[black]
+$setFont[Roboto;30]
+$drawText[User: {username};20;20]
+$drawText[Score: {score};20;60]
+"""
+
+image_bytes = await engine.render_template(template, data=data)
+```
+
+### Advanced Masking
+AlphaPIL supports complex masking for creating avatars or stylized images:
+
+```python
+template = """
+$createCanvas[400;400;transparent]
+$createLayer[mask]
+$drawCircle[200;200;180;white]
+$switchLayer[main]
+$drawImage[https://example.com/avatar.png;0;0;400;400]
+$applyMask[mask]
+"""
+```
+
+### Support
+Need help? Join our official Discord community for support and updates!
+**[Join MeraLabs Discord](https://discord.gg/AXbuM6aaeQ)**
+
+### Contributing
+Refer to the [Contribution Documentation](https://github.com/MeraLabs/AlphaPIL/blob/main/CONTRIBUTING.md) for more information.
+
+### Keywords
+`alphapil` `image-generation` `pillow` `python` `async` `discord-bot` `template-engine` `meralabs` `canvas` `dsl`

alphapil-0.1.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "alphapil"
+version = "0.1.0"
+description = "An asynchronous, template-based image generation engine"
+authors = [{name = "AlphaPIL Team", email = "team@alphapil.dev"}]
+license = "MIT"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+]
+dependencies = [
+    "Pillow>=9.0.0",
+    "aiohttp>=3.8.0",
+    "discord.py>=2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "black>=22.0.0",
+    "isort>=5.10.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/MeraLabs/AlphaPIL"
+Repository = "https://github.com/MeraLabs/AlphaPIL"
+Documentation = "https://alphapil.readthedocs.io"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-dir]
+"" = "src"
+
+[tool.black]
+line-length = 88
+target-version = ['py38']
+
+[tool.isort]
+profile = "black"
+line_length = 88

alphapil-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

alphapil-0.1.0/src/alphapil/__init__.py

@@ -0,0 +1,24 @@
+"""
+AlphaPIL - An asynchronous, template-based image generation engine.
+
+This package provides a powerful recursive parser for handling nested functions
+in image generation templates, with support for asynchronous operations.
+"""
+
+__version__ = "0.1.0"
+__author__ = "AlphaPIL Team"
+
+from .engine import CanvasEngine
+from .interpreter import CanvasInterpreter
+from .modules import AlphaMixin, ShapesMixin, TextMixin, ImagesMixin, UtilsMixin, MaskingMixin
+
+__all__ = [
+    "CanvasEngine", 
+    "CanvasInterpreter", 
+    "AlphaMixin", 
+    "ShapesMixin", 
+    "TextMixin", 
+    "ImagesMixin",
+    "UtilsMixin",
+    "MaskingMixin"
+]

alphapil-0.1.0/src/alphapil/engine.py

@@ -0,0 +1,259 @@
+"""
+CanvasEngine - High-level canvas operations for AlphaPIL.
+
+This module provides the CanvasEngine class that inherits from CanvasInterpreter
+and all module mixins to provide comprehensive image generation capabilities.
+"""
+
+import io
+from typing import Tuple, Union, Optional
+from PIL import Image, ImageDraw, ImageFont
+from .interpreter import CanvasInterpreter
+from .modules import AlphaMixin, ShapesMixin, TextMixin, ImagesMixin, UtilsMixin, MaskingMixin
+
+
+class CanvasEngine(CanvasInterpreter, AlphaMixin, ShapesMixin, TextMixin, ImagesMixin, UtilsMixin, MaskingMixin):
+    """
+    High-level canvas engine that extends CanvasInterpreter with Pillow-based
+    image generation capabilities and all module mixins.
+    """
+    
+    def __init__(self):
+        """Initialize the canvas engine and register built-in functions."""
+        # Initialize all parent classes properly
+        CanvasInterpreter.__init__(self)
+        AlphaMixin.__init__(self)
+        ShapesMixin.__init__(self)
+        TextMixin.__init__(self)
+        ImagesMixin.__init__(self)
+        UtilsMixin.__init__(self)
+        MaskingMixin.__init__(self)
+        
+        # Initialize mixin states
+        self._init_state()
+        self._init_text()
+        
+        # Initialize canvas-specific attributes
+        self.canvas: Optional[Image.Image] = None
+        self.draw: Optional[ImageDraw.Draw] = None
+        self.canvas_size: Tuple[int, int] = (0, 0)
+        
+        # Register all built-in functions from modules
+        self._register_builtin_functions()
+    
+    async def render_template(self, template_text: str, data: dict = None) -> bytes:
+        """
+        Render a template with optional data injection (Async).
+        
+        Args:
+            template_text: Template content as string
+            data: Optional dictionary of variables to set
+            
+        Returns:
+            Canvas image as bytes
+            
+        Raises:
+            RuntimeError: If template rendering fails
+        """
+        try:
+            # Reset engine state
+            self.reset()
+            
+            # Inject data if provided
+            if data:
+                for key, value in data.items():
+                    self.set_variable(key, str(value))
+            
+            # Parse template line by line
+            lines = template_text.strip().split('\n')
+            for line_num, line in enumerate(lines, 1):
+                line = line.strip()
+                
+                # Skip comments and empty lines
+                if not line or line.startswith('#'):
+                    continue
+                
+                # Parse and execute the line (awaiting async parse)
+                result = await self.parse(line)
+            
+            # Return canvas as bytes
+            return self.get_canvas_bytes()
+            
+        except Exception as e:
+            raise RuntimeError(f"Template rendering failed: {e}")
+    
+    async def render_template_file(self, template_path: str, data: dict = None) -> bytes:
+        """
+        Render a template from file with optional data injection (Async).
+        
+        Args:
+            template_path: Path to template file
+            data: Optional dictionary of variables to set
+            
+        Returns:
+            Canvas image as bytes
+            
+        Raises:
+            FileNotFoundError: If template file doesn't exist
+            RuntimeError: If template rendering fails
+        """
+        try:
+            # Use async file reading if possible, but standard open is fine for text files
+            # or could use aiofiles if dependency added. For now sync read is okay.
+            with open(template_path, 'r', encoding='utf-8') as f:
+                template_text = f.read()
+            return await self.render_template(template_text, data)
+        except FileNotFoundError:
+            raise FileNotFoundError(f"Template file not found: {template_path}")
+        except Exception as e:
+            raise RuntimeError(f"Template rendering failed: {e}")
+    
+    def _register_builtin_functions(self) -> None:
+        """Register all built-in canvas manipulation functions from all modules."""
+        # Core canvas functions
+        self.register_function("createCanvas", self._create_canvas)
+        self.register_function("save", self._save_canvas)
+        self.register_function("setVar", self._set_var)
+        
+        # State management functions
+        # State management functions - Registered at end to use new implementations
+        # self.register_function("setFont", self._set_font)
+        # self.register_function("setColor", self._set_color)
+        # self.register_function("setStroke", self._set_stroke)
+        
+        # Shape functions from ShapesMixin
+        self.register_function("drawRect", self._draw_rect)
+        self.register_function("drawCircle", self._draw_circle)
+        self.register_function("drawRoundedRect", self._draw_rounded_rect)
+        self.register_function("drawLine", self._draw_line)
+        
+        # Text functions from TextMixin
+        self.register_function("drawText", self._draw_text)
+        self.register_function("drawTextStroke", self._draw_text_stroke)
+        self.register_function("drawTextGradient", self._draw_text_gradient)
+        self.register_function("toUpper", self._to_upper)
+        self.register_function("toLower", self._to_lower)
+        self.register_function("toTitle", self._to_title)
+        self.register_function("measureText", self._measure_text)
+        self.register_function("wrapText", self._wrap_text)
+        self.register_function("autoSizeText", self._auto_size_text)
+        self.register_function("truncateText", self._truncate_text)
+        self.register_function("drawTextMid", self._draw_text_mid)
+        self.register_function("drawTextIn", self._draw_text_in)
+        
+        # Image functions from ImagesMixin
+        self.register_function("drawImage", self._draw_image)
+        self.register_function("useImageAsCanvas", self._use_image_as_canvas)
+        self.register_function("imageFilter", self._image_filter)
+        self.register_function("clearImageCache", self.clear_image_cache)
+        
+        # Utility functions from UtilsMixin
+        self.register_function("math", self._math)
+        self.register_function("if", self._if)
+        self.register_function("random", self._random)
+        self.register_function("getHex", self._get_hex)
+        self.register_function("replace", self._replace)
+        self.register_function("length", self._length)
+        self.register_function("substring", self._substring)
+        self.register_function("join", self._join)
+        self.register_function("split", self._split)
+
+        # Masking functions from MaskingMixin
+        self.register_function("createLayer", self._create_layer)
+        self.register_function("switchLayer", self._switch_layer)
+        self.register_function("mergeLayer", self._merge_layer)
+        self.register_function("applyMask", self._apply_mask)
+
+        # State management commands
+        self.register_function("setFont", self._cmd_set_font)
+        self.register_function("loadFont", self._load_font)
+        self.register_function("setColor", self._cmd_set_color)
+        self.register_function("setStroke", self._cmd_set_stroke)
+    
+    def _create_canvas(self, width: str, height: str, color: str = "white") -> str:
+        """
+        Create a new canvas with specified dimensions and background color.
+        
+        Args:
+            width: Canvas width as string
+            height: Canvas height as string  
+            color: Background color (default: "white")
+            
+        Returns:
+            Confirmation message
+        """
+        try:
+            w = int(width)
+            h = int(height)
+            self.canvas_size = (w, h)
+            
+            # Parse color using the helper from AlphaMixin
+            bg_color = self._get_color(color) or (255, 255, 255)
+            
+            self.canvas = Image.new("RGB", (w, h), bg_color)
+            self.draw = ImageDraw.Draw(self.canvas)
+            return f"Canvas created: {w}x{h}"
+        except ValueError as e:
+            raise ValueError(f"Invalid canvas dimensions: {e}")
+    
+    def _set_var(self, name: str, value: str) -> str:
+        """
+        Set a variable value.
+        
+        Args:
+            name: Variable name (without {} wrapper)
+            value: Variable value
+            
+        Returns:
+            Confirmation message
+        """
+        self.set_variable(name, value)
+        return f"Variable {name} set to {value}"
+    
+    def _save_canvas(self, filename: str = "output.png") -> str:
+        """
+        Save the current canvas to a file with maximum quality.
+        """
+        if not self.canvas:
+            raise RuntimeError("No canvas to save. Call $createCanvas first.")
+        
+        try:
+            # Set high quality parameters for various formats
+            save_params = {"optimize": True}
+            if filename.lower().endswith(('.jpg', '.jpeg')):
+                save_params.update({"quality": 100, "subsampling": 0})
+            
+            self.canvas.save(filename, **save_params)
+            return f"Canvas saved as {filename}"
+        except Exception as e:
+            raise RuntimeError(f"Failed to save canvas: {e}")
+    
+    def get_canvas_bytes(self, format: str = "PNG") -> bytes:
+        """
+        Get the canvas as bytes with maximum quality.
+        """
+        if not self.canvas:
+            raise RuntimeError("No canvas available. Call $createCanvas first.")
+        
+        img_bytes = io.BytesIO()
+        
+        # Set high quality parameters
+        save_params = {"format": format, "optimize": True}
+        if format.upper() in ["JPEG", "JPG"]:
+            save_params.update({"quality": 100, "subsampling": 0})
+            
+        self.canvas.save(img_bytes, **save_params)
+        img_bytes.seek(0)
+        return img_bytes.getvalue()
+    
+    def reset(self) -> None:
+        """Reset the canvas, drawing context, and state."""
+        self.canvas = None
+        self.draw = None
+        self.canvas_size = (0, 0)
+        self._init_state()
+        self._init_text()
+        if hasattr(self, '_image_cache'):
+            self._image_cache.clear()
+            
+    # State management is now handled via AlphaMixin _cmd_* methods