stackraise 0.1.0__py3-none-any.whl

stackraise/model/time_range.py

@@ -0,0 +1,285 @@
+# %%
+from __future__ import annotations
+
+import re
+from dataclasses import replace
+from datetime import UTC
+from datetime import date as Date
+from datetime import datetime as DateTime
+from datetime import time as Time
+from datetime import timedelta as TimeDelta
+from datetime import timezone as TimeZone
+from typing import Optional, TypeAlias
+
+from pydantic.dataclasses import dataclass
+
+TimeDeltaParseable: TypeAlias = int | str | TimeDelta
+
+
+DateTimeParseable: TypeAlias = int | str | Date | DateTime
+
+
+@dataclass(frozen=True, slots=True)
+class TimeRange:
+    start: DateTime
+    stop: DateTime
+
+    @property
+    def is_for_an_exact_day(self) -> Optional[Date]:
+        if _datetime_is_day_exact(self.start) and self.stop == _datetime_next_day(
+            self.start
+        ):
+            return self.start.date()
+
+    @property
+    def is_for_exact_days(self) -> bool:
+        return _datetime_is_day_exact(self.start) and _datetime_is_day_exact(self.stop)
+
+    @property
+    def is_for_an_exact_month(self) -> bool:
+        return _datetime_is_month_exact(self.start) and self.stop == _datetime_next_month(
+            self.start
+        )
+
+    @property
+    def is_for_exact_months(self) -> bool:
+        return _datetime_is_month_exact(self.start) and _datetime_is_month_exact(
+            self.stop
+        )
+
+    @property
+    def is_for_an_exact_year(self) -> bool:
+        return _datetime_is_year_exact(self.start) and self.stop == _datetime_next_year(
+            self.start
+        )
+
+    @property
+    def is_for_exact_years(self) -> bool:
+        return _datetime_is_year_exact(self.start) and _datetime_is_year_exact(self.stop)
+
+    @property
+    def extent(self) -> TimeDelta:
+        return self.stop - self.start
+
+    @classmethod
+    def of(cls, s: TimeRangeParseable):
+        if isinstance(s, TimeRange):
+            return s
+        if isinstance(s, str):
+            return _parse_timerange(s)
+
+        raise ValueError(f"Invalid TimeRange string: {s}")
+
+    def __str__(self):
+        if self.is_for_an_exact_year:
+            fmt = f"{self.start.year}"
+        elif self.is_for_an_exact_month:
+            fmt = f"{self.start.year}-{self.start.month:02}"
+        elif self.is_for_an_exact_day:
+            fmt = f"{self.start.date()}"
+        else:
+            fmt = f"{_repr_datetime(self.start)}..{_repr_datetime(self.stop)}"
+
+        return fmt
+
+    @property
+    def duration(self) -> TimeDelta:
+        return self.stop - self.start
+
+    def __contains__(self, dt: DateTime):
+        return self.start <= dt < self.stop
+
+    def replace(self, **kwargs):
+        return replace(self, **kwargs)
+
+    @classmethod
+    def overlap(cls, a: TimeRange, b: TimeRange) -> Optional[TimeRange]:
+        start = max(a.start, b.start)
+        stop = min(a.stop, b.stop)
+        if start < stop:
+            return cls(start=start, stop=stop)
+
+
+TimeRangeParseable: TypeAlias = str | TimeRange
+
+# Expresiones regulares
+DELTA_REGEX = re.compile(
+    r"^(?:(?P<days>\d+)d)?\s?"  # Días opcionales
+    r"(?:(?P<hours>\d+)h)?\s?"  # Horas opcionales
+    r"(?:(?P<minutes>\d+)m)?\s?"  # Minutos opcionales
+    r"(?:(?P<seconds>\d+)s)?$\s?"  # Segundos opcionales
+)
+
+
+def _parse_timedelta(s: TimeDeltaParseable) -> TimeDelta:
+    if isinstance(s, TimeDelta):
+        return s
+    if isinstance(s, int):
+        return TimeDelta(milliseconds=s)
+
+    match = DELTA_REGEX.match(s)
+    if not match:
+        raise ValueError(f"Invalid timedelta string: {s}")
+
+    return TimeDelta(
+        **{key: int(value) for key, value in match.groupdict(default="0").items()}
+    )
+
+
+DATE_REGEXES = [
+    re.compile(r"^(?P<year>\d{4})$"),  # Solo año
+    re.compile(r"^(?P<year>\d{4})-(?P<month>\d{2})$"),  # Año y mes
+    re.compile(r"^(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})$"),  # Año, mes y día
+    re.compile(
+        r"^(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})T(?P<hour>\d{2}):(?P<minute>\d{2})(?::(?P<second>\d{2}))?$"
+    ),  # Fecha y hora
+]
+
+
+def _parse_datetime(dt: DateTimeParseable) -> DateTime:
+    if isinstance(dt, int):
+        return DateTime.fromtimestamp(dt).replace(tzinfo=TimeZone.utc)
+    elif isinstance(dt, str):
+        try:
+            for regex in DATE_REGEXES:
+                if match := regex.match(dt):
+                    components = match.groupdict()
+                    return DateTime(
+                        year=int(components["year"]),
+                        month=int(components.get("month", 1)),
+                        day=int(components.get("day", 1)),
+                        hour=int(components.get("hour", 0)),
+                        minute=int(components.get("minute", 0)),
+                        second=int(components.get("second", 0)),
+                        tzinfo=UTC,
+                    )
+            raise ValueError(f"Invalid date time string: {dt}")
+
+        except:
+            dt = Date.fromisoformat(dt)
+
+    if isinstance(dt, Date):
+        return DateTime.combine(dt, Time.min).replace(tzinfo=UTC)
+    elif isinstance(dt, DateTime):
+        return DateTime.fromtimestamp(dt.timestamp()).replace(tzinfo=UTC)
+    else:
+        raise ValueError(f"Invalid type {type(dt)}")
+
+
+RANGE_REGEX = re.compile(
+    r"^"
+    # Rango explícito "start .. stop"
+    r"((?P<start>.+?)\s*\.\.\s*(?P<stop>.+?)(\s)?)"
+    r"$"
+)
+
+RANGE_SEP = re.compile(r"[\s_]+")
+
+
+def _parse_timerange(input_str: str) -> TimeRange:
+    """
+    Parsea una cadena de entrada para determinar el rango de tiempo y el delta.
+    """
+    # Detectar rango explícito
+    range_match = RANGE_REGEX.match(input_str)
+    if range_match:
+        start = _parse_datetime(range_match.group("start"))
+        stop = _parse_datetime(range_match.group("stop"))
+        return TimeRange(start=start, stop=stop)
+
+    # Detectar rango implícito (un solo valor)
+    start = _parse_datetime(input_str)
+    if len(input_str) == 4:  # Año
+        stop = _datetime_next_year(start)
+    elif len(input_str) == 7:  # Año y mes
+        stop = _datetime_next_month(start)
+    elif len(input_str) == 10:  # Año, mes y día
+        stop = _datetime_next_day(start)
+    else:
+        raise ValueError(f"Invalid TimeRange string: {input_str}")
+
+    return TimeRange(start=start, stop=stop)
+
+
+def _repr_timedelta(time_delta: TimeDelta):
+    parts = []
+    if time_delta < TimeDelta():
+        time_delta = -time_delta
+        parts.append("-")
+
+    weeks, days = divmod(time_delta.days, 7)
+    hours, seconds = divmod(time_delta.seconds, 3600)
+    minutes, seconds = divmod(seconds, 60)
+
+    if weeks:
+        parts.append(f"{weeks}w")
+    if days:
+        parts.append(f"{days}d")
+    if hours:
+        parts.append(f"{hours}h")
+    if minutes:
+        parts.append(f"{minutes}m")
+    if seconds:
+        parts.append(f"{seconds}s")
+
+    return "".join(parts)
+
+
+def _repr_datetime(dt: DateTime) -> str:
+    if _datetime_is_year_exact(dt):
+        return str(dt.year)
+    if _datetime_is_month_exact(dt):
+        return f"{dt.year}-{dt.month:02}"
+    if _datetime_is_day_exact(dt):
+        return str(dt.date())
+    return dt.isoformat()
+
+
+def _datetime_is_day_exact(dt: DateTime) -> bool:
+    return dt.time() == Time.min
+
+def _datetime_is_month_exact(dt: DateTime) -> bool:
+    return dt.day == 1 and _datetime_is_day_exact(dt)
+
+def _datetime_is_year_exact(dt: DateTime) -> bool:
+    return dt.month == 1 and _datetime_is_month_exact(dt)
+
+def _datetime_next_day(dt: DateTime) -> DateTime:
+    return dt + TimeDelta(days=1)
+
+def _datetime_next_month(dt: DateTime) -> DateTime:
+    if dt.month == 12:
+        return dt.replace(year=dt.year + 1, month=1)
+    return dt.replace(month=dt.month + 1)
+
+def _datetime_next_year(dt: DateTime) -> DateTime:
+    return dt.replace(year=dt.year + 1)
+
+
+# Test cases
+if __name__ == "__main__":
+    # assert _parse_timedelta("1d") == TimeDelta(days=1)
+    # assert _parse_timedelta("1d 2h 3m 4s") == TimeDelta(
+    #     days=1, hours=2, minutes=3, seconds=4
+    # )
+    # assert _parse_timedelta("1d 2h 3m") == TimeDelta(days=1, hours=2, minutes=3)
+
+    assert TimeRange.of("2024").is_for_an_exact_year
+
+    examples = [
+        "2024",  # Año completo, paso predeterminado (1 día)
+        "2024-01",  # Mes completo, paso predeterminado (1 día)
+        "2024-01-01",  # Día completo, paso predeterminado (1 día)
+        "2024-01-01T12:00:00",  # Fecha y hora exacta
+        "2024-01 .. 2024-07",  # Rango de un año, paso de 1 hora
+        "2024-01-01 .. 2024-07-01",  # Rango explícito con delta
+    ]
+
+    for example in examples:
+        try:
+            result = TimeRange.of(example)
+            print(f"Input: {example}\nParsed: {result}\n")
+        except ValueError as e:
+            print(f"Input: {example}\nError: {e}\n")
+
+# %%

stackraise/model/validation.py

@@ -0,0 +1,8 @@
+from typing import NoReturn
+from fastapi import HTTPException
+
+def validation_error(msg: str) -> NoReturn:
+    """Convención con el frotend para lanzar excepciones de validación desde el backend"""
+    raise HTTPException(status_code=400, detail=msg)
+
+

stackraise/templating/__init__.py

@@ -0,0 +1,4 @@
+from .pptx import *
+from .parser import *
+from .tracer import *
+from .image import *

stackraise/templating/exceptions.py

@@ -0,0 +1,23 @@
+class PptxTemplateEngineError(Exception):
+    """Base para errores del motor de plantillas PPTX"""
+    pass
+
+
+class TemplateSyntaxError(PptxTemplateEngineError):
+    pass
+
+
+class UndefinedVariableError(PptxTemplateEngineError):
+    pass
+
+
+class ContextError(PptxTemplateEngineError):
+    pass
+
+
+class TemplateNotFoundError(PptxTemplateEngineError):
+    pass
+
+
+class RenderError(PptxTemplateEngineError):
+    pass

stackraise/templating/image/__init__.py

@@ -0,0 +1,2 @@
+from .model import *
+from .processor import *

stackraise/templating/image/model.py

@@ -0,0 +1,51 @@
+from pydantic import BaseModel
+from typing import Union, Optional
+from pathlib import Path
+from io import BytesIO
+from stackraise.model.file import File
+
+class ImageData(BaseModel):
+    """Modelo para representar imágenes en el contexto de plantillas PPTX"""
+    
+    # Datos de la imagen
+    data: Union[bytes, str, Path]  # bytes, ruta como string, o Path object
+    
+    # Metadatos opcionales
+    width: Optional[float] = None  # Ancho en pulgadas
+    height: Optional[float] = None  # Alto en pulgadas
+    
+    # Para mantener aspect ratio
+    max_width: Optional[float] = None
+    max_height: Optional[float] = None
+    
+    @classmethod
+    def from_bytes(cls, data: bytes, width: Optional[float] = None, height: Optional[float] = None):
+        """Crear ImageData desde bytes"""
+        return cls(data=data, width=width, height=height)
+    
+    @classmethod
+    def from_path(cls, path: Union[str, Path], width: Optional[float] = None, height: Optional[float] = None):
+        """Crear ImageData desde ruta de archivo"""
+        return cls(data=Path(path), width=width, height=height)
+    
+    @classmethod
+    def from_url(cls, url: str, width: Optional[float] = None, height: Optional[float] = None):
+        """Crear ImageData desde URL (requiere descarga previa)"""
+        # TODO: Implementar descarga de imagen desde URL
+        return cls(data=url, width=width, height=height)
+    
+    @classmethod
+    async def from_file_ref(cls, file_ref: File.Ref):
+        file: File = await file_ref.fetch()
+        content = await file.content()
+        return cls.from_bytes(content)
+
+    def get_bytes(self) -> bytes:
+        """Obtener los bytes de la imagen"""
+        if isinstance(self.data, bytes):
+            return self.data
+        elif isinstance(self.data, (str, Path)):
+            with open(self.data, 'rb') as f:
+                return f.read()
+        else:
+            raise ValueError(f"Tipo de data no soportado: {type(self.data)}")

stackraise/templating/image/processor.py

@@ -0,0 +1,154 @@
+from pptx.slide import Slide
+from pptx.util import Inches
+from pptx.enum.shapes import MSO_SHAPE_TYPE
+from io import BytesIO
+from ..image import ImageData
+from ..parser import extract_image_variables
+from ..tracer import Tracer
+import re
+
+"""
+Procesa variables de tipo ImageData en slides de PPTX.
+TODO: Refactor para otro tipo de archivos. El tracer y el parser deberian estar a nivel de templating
+"""
+
+class ImageProcessor:
+    """Procesa variables de tipo ImageData en slides de PPTX"""
+    
+    @staticmethod
+    def process_slide_images(slide: Slide, context: dict, tracer: Tracer):
+        """
+        Procesa todas las variables ImageData en una slide, reemplazando
+        los placeholders {{variable}} con las imágenes reales.
+        """
+        shapes_to_remove = []
+        
+        for shape in slide.shapes:
+            if shape.has_text_frame:
+                # Buscar variables ImageData en texto
+                text_content = shape.text_frame.text
+                image_vars = extract_image_variables(text_content, context)
+                
+                if image_vars:
+                    # Si hay variables de imagen en este shape
+                    for image_var in image_vars:
+                        image_data = ImageProcessor._get_nested_value(context, image_var)
+                        if isinstance(image_data, ImageData):
+                            # Verificar si el shape contiene SOLO la variable de imagen
+                            clean_text = text_content.strip()
+                            var_pattern = r"""^\{\{\s*""" + re.escape(image_var) + r"""\s*\}\}$"""
+                            
+                            if re.match(var_pattern, clean_text):
+                                # El shape contiene SOLO la imagen, reemplazarlo completamente
+                                ImageProcessor._replace_shape_with_image(
+                                    slide, shape, image_var, image_data, tracer
+                                )
+                                shapes_to_remove.append(shape)
+                            else:
+                                # El shape tiene texto mixto, insertar imagen cerca
+                                ImageProcessor._insert_image_near_text(
+                                    slide, shape, image_var, image_data, tracer
+                                )
+        
+        # Remover shapes que fueron reemplazados por imágenes
+        for shape in shapes_to_remove:
+            sp = shape._element
+            sp.getparent().remove(sp)
+    
+    @staticmethod
+    def _get_nested_value(context: dict, var_path: str):
+        """
+        Obtiene el valor de una variable anidada (ej: client.logo)
+        """
+        value = context
+        for part in var_path.split('.'):
+            value = value[part]
+        return value
+    
+    @staticmethod
+    def _replace_shape_with_image(slide: Slide, text_shape, image_var: str, image_data: ImageData, tracer: Tracer):
+        """
+        Reemplaza completamente un shape de texto con una imagen.
+        """
+        try:
+            # Obtener posición y tamaño del shape de texto
+            left = text_shape.left
+            top = text_shape.top
+            # width = text_shape.width
+            # height = text_shape.height
+            
+            # Obtener los bytes de la imagen
+            image_bytes = image_data.get_bytes()
+            image_stream = BytesIO(image_bytes)
+            image_stream.seek(0)
+            
+            # Calcular dimensiones finales
+            final_width = Inches(image_data.width) if image_data.width else None
+            final_height = Inches(image_data.height) if image_data.height else None
+
+            # Si hay límites máximos, aplicarlos manteniendo aspect ratio
+            if image_data.max_width or image_data.max_height:
+                final_width, final_height = ImageProcessor._calculate_constrained_size(
+                    final_width, final_height, image_data.max_width, image_data.max_height
+                )
+            
+            # Añadir la imagen al slide
+            picture = slide.shapes.add_picture(
+                image_stream, left, top, final_width, final_height
+            )
+            
+            tracer.log_variable(f"{image_var}", f"Imagen insertada ({final_width}x{final_height})")
+            
+        except Exception as e:
+            tracer.log_error(f"Error insertando imagen '{image_var}': {e}")
+    
+    @staticmethod
+    def _insert_image_near_text(slide: Slide, text_shape, image_var: str, image_data: ImageData, tracer: Tracer):
+        """
+        Inserta una imagen cerca de un shape de texto que contiene contenido mixto.
+        """
+        try:
+            # Calcular posición para la imagen (debajo del texto)
+            left = text_shape.left
+            top = text_shape.top + text_shape.height + Inches(0.1)  # 0.1" de separación
+            
+            # Obtener los bytes de la imagen
+            image_bytes = image_data.get_bytes()
+            image_stream = BytesIO(image_bytes)
+            
+            # Usar dimensiones especificadas o tamaño por defecto
+            final_width = Inches(image_data.width) if image_data.width else Inches(2.0)
+            final_height = Inches(image_data.height) if image_data.height else Inches(1.5)
+            
+            # Si hay límites máximos, aplicarlos
+            if image_data.max_width or image_data.max_height:
+                final_width, final_height = ImageProcessor._calculate_constrained_size(
+                    final_width, final_height, image_data.max_width, image_data.max_height
+                )
+            
+            # Añadir la imagen al slide
+            picture = slide.shapes.add_picture(
+                image_stream, left, top, final_width, final_height
+            )
+            
+            tracer.log_variable(f"{image_var}", f"Imagen insertada cerca del texto ({final_width}x{final_height})")
+            
+        except Exception as e:
+            tracer.log_error(f"Error insertando imagen '{image_var}': {e}")
+    
+    @staticmethod
+    def _calculate_constrained_size(width, height, max_width=None, max_height=None):
+        """
+        Calcula el tamaño final manteniendo aspect ratio dentro de los límites.
+        """
+        if max_width:
+            max_width = Inches(max_width)
+        if max_height:
+            max_height = Inches(max_height)
+            
+        # Calcular factor de escala
+        scale_x = max_width / width if max_width and width > max_width else 1
+        scale_y = max_height / height if max_height and height > max_height else 1
+        scale = min(scale_x, scale_y)
+        
+        return width * scale, height * scale

stackraise/templating/parser.py

@@ -0,0 +1,156 @@
+from typing import Any, Dict, List, Optional
+from jinja2 import Environment, meta, StrictUndefined
+import re
+
+def create_jinja_env():
+    return Environment(
+        undefined=StrictUndefined,
+        autoescape=False,
+        trim_blocks=True,
+        lstrip_blocks=True
+    )
+
+def extract_variables_from_text(text: str, jinja_env: Environment):
+    ast = jinja_env.parse(text)
+    return meta.find_undeclared_variables(ast)
+
+def extract_slide_loop(text: str) -> Optional[tuple[str, str, str]]:
+    #pattern = r"""\{%\s*for\s+(\w+)\s+(of|in)\s+(\w+)\s*%\}"""
+    pattern = r"""\{%\s*for\s+(\w+)\s+(of|in)\s+(.+?)\s*%\}"""
+    match = re.search(pattern, text)
+    if match:
+        var, tipo, lista = match.groups()
+        return var, lista, tipo
+    return None
+
+def extract_image_variables(text: str, context: dict) -> List[str]:
+    """
+    Extrae variables que son de tipo ImageData del contexto
+    """
+    
+    from .image.model import ImageData
+
+    # Buscar todas las variables en el texto
+    pattern = r"""\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)\s*\}\}"""
+    variables = re.findall(pattern, text)
+    
+    # Filtrar solo las que son ImageData
+    image_vars = []
+    for var in variables:
+        # Navegar por variables anidadas (ej: client.logo)
+        value = context
+        try:
+            for part in var.split('.'):
+                value = value[part]
+            if isinstance(value, ImageData):
+                image_vars.append(var)
+        except (KeyError, TypeError):
+            continue
+    
+    return image_vars
+
+def has_image_variables(text: str, context: dict) -> bool:
+    """
+    Verifica si el texto contiene variables de tipo ImageData
+    """
+    return len(extract_image_variables(text, context)) > 0
+
+def preprocess_text_for_jinja(text: str, context: dict = None) -> str:
+    """
+    Preprocesa el texto para convertir 'of' a 'in' en bucles de texto
+    y remover variables ImageData (se procesan por separado)
+    """
+    # Convertir {% for var of list %} a {% for var in list %}
+    #pattern = r"""(\{%\s*for\s+\w+\s+)of(\s+\w+\s*%\})"""
+    pattern = r"""(\{%\s*for\s+\w+\s+)of(\s+.+?\s*%\})"""
+    converted_text = re.sub(pattern, r'\1in\2', text)
+    
+    # Si tenemos contexto, remover variables ImageData
+    if context:
+        image_vars = extract_image_variables(text, context)
+        for var in image_vars:
+            # Reemplazar {{imagen_var}} con placeholder vacío
+            var_pattern = r"""\{\{\s*""" + re.escape(var) + r"""\s*\}\}"""
+            converted_text = re.sub(var_pattern, "", converted_text)
+    
+    return converted_text
+
+def extract_slide_conditional_block(text: str) -> Optional[Dict[str, Any]]:
+    """
+    Extrae un bloque condicional completo incluyendo if/elif/else.
+    Retorna un diccionario con la estructura del condicional.
+    """
+    # Patrón para capturar bloques if completos con elif y else opcionales
+    pattern = r"""\{%\s*if\s+(.+?)\s*%\}(.*?)(?:\{%\s*elif\s+(.+?)\s*%\}(.*?))*(?:\{%\s*else\s*%\}(.*?))?\{%\s*endif\s*%\}"""
+    
+    match = re.search(pattern, text, re.DOTALL)
+    if match:
+        if_condition = match.group(1).strip()
+        return {
+            'type': 'conditional_block',
+            'if_condition': if_condition,
+            'has_block_structure': True
+        }
+    
+    # Patrón más simple para detectar si hay una condición en la slide
+    simple_pattern = r"""\{%\s*if\s+(.+?)\s*%\}"""
+    simple_match = re.search(simple_pattern, text)
+    if simple_match:
+        condition = simple_match.group(1).strip()
+        return {
+            'type': 'simple_conditional',
+            'condition': condition,
+            'has_block_structure': False
+        }
+    
+    return None
+
+def extract_slide_conditional(text: str) -> Optional[str]:
+    """
+    Extrae la condición de un bloque if en una slide.
+    Retorna la condición si encuentra un bloque {% if condition %}
+    """
+    pattern = r"""\{%\s*if\s+(.+?)\s*%\}"""
+    match = re.search(pattern, text)
+    if match:
+        condition = match.group(1).strip()
+        return condition
+    return None
+
+def evaluate_condition(condition: str, context: dict, jinja_env: Environment) -> bool:
+    """
+    Evalúa una condición de Jinja2 contra el contexto dado.
+    """
+    try:
+        # Crear una plantilla simple que evalúe la condición
+        template_text = f"{{% if {condition} %}}TRUE{{% else %}}FALSE{{% endif %}}"
+        template = jinja_env.from_string(template_text)
+        result = template.render(context)
+        return result == "TRUE"
+    except Exception as e:
+        raise ValueError(f"Error evaluando condición '{condition}': {e}")
+
+def evaluate_conditional_block(text: str, context: dict, jinja_env: Environment) -> bool:
+    """
+    Evalúa un bloque condicional completo con if/elif/else.
+    Retorna True si alguna condición se cumple o hay un else.
+    """
+    try:
+        # Preprocesar para convertir 'of' a 'in'
+        processed_text = preprocess_text_for_jinja(text)
+        # Renderizar el bloque completo y ver si produce contenido
+        template = jinja_env.from_string(processed_text)
+        result = template.render(context).strip()
+        # Si el resultado no está vacío, significa que alguna condición se cumplió
+        return bool(result)
+    except Exception as e:
+        raise ValueError(f"Error evaluando bloque condicional: {e}")
+
+def render_text(text: str, context: dict, jinja_env: Environment) -> str:
+    try:
+        # Preprocesar para convertir 'of' a 'in' y remover ImageData
+        processed_text = preprocess_text_for_jinja(text, context)
+        template = jinja_env.from_string(processed_text)
+        return template.render(context)
+    except Exception as e:
+        raise

stackraise/templating/pptx/__init__.py

@@ -0,0 +1,3 @@
+from ..exceptions import *
+from .pptx_engine import *
+from .slide_renderer import *