stackraise 0.1.0__py3-none-any.whl

stackraise/templating/pptx/pptx_engine.py

@@ -0,0 +1,204 @@
+import re
+from typing import Optional, Union
+from pathlib import Path
+from io import BytesIO
+
+from pptx import Presentation
+from pptx.slide import Slide
+from pydantic import BaseModel
+
+from ..parser import create_jinja_env, evaluate_condition, evaluate_conditional_block, extract_slide_conditional_block, extract_slide_loop
+from .slide_renderer import render_slide
+from ..tracer import Tracer
+from ..exceptions import TemplateNotFoundError, RenderError
+from copy import deepcopy
+
+"""
+TODO: Implementar soporte para variables de tipo 'of' en los bucles de Jinja2.
+    Este operador permite iterar sobre listas y para cada elemento generar
+    un slide duplicado con el contexto actualizado.
+"""
+
+
+class PptxTemplateEngine:
+
+    @staticmethod
+    def _resolve_path(ctx: dict, path: str):
+        """
+        Resuelve rutas 'a.b.c' en dicts/objetos simples.
+        """
+        cur = ctx
+        for part in [p.strip() for p in path.split('.') if p.strip()]:
+            if isinstance(cur, dict):
+                cur = cur.get(part, None)
+            else:
+                cur = getattr(cur, part, None)
+            if cur is None:
+                return None
+        return cur
+
+    @staticmethod
+    def render_from_template(
+        context: BaseModel,
+        template_path: str,
+        output_path: Optional[str] = None
+    ) -> Union[str, BytesIO]:
+        tracer = Tracer()
+        tracer.start()
+
+        template_file = Path(template_path)
+        if not template_file.exists():
+            raise TemplateNotFoundError(f"Plantilla no encontrada en ruta: {template_path}")
+
+        try:
+            prs = Presentation(template_path)
+            # serializar el model pero RESTAURAR objetos ImageData top-level
+            context_dict = context.model_dump(by_alias=False, mode="python")
+            try:
+                # import tardío para evitar ciclos
+                from stackraise.templating.image.model import ImageData
+            except Exception:
+                ImageData = None
+
+            if ImageData is not None:
+                # Restaurar campos top-level que en el BaseModel son instancias ImageData
+                for name, raw_value in context.__dict__.items():
+                   if isinstance(raw_value, ImageData):
+                        context_dict[name] = raw_value
+                        
+            jinja_env = create_jinja_env()
+
+            slides = list(prs.slides)
+            slides_to_remove = []
+
+            for idx, slide in enumerate(slides):
+                loop_found = False
+                slide_level_conditional_found = False
+
+                # Buscar en todas las formas de texto de la slide
+                slide_text = ""
+                for shape in slide.shapes:
+                    if shape.has_text_frame:
+                        slide_text += shape.text_frame.text + " "
+
+                # Primero verificar si hay un bucle A NIVEL DE SLIDE
+                loop_info = extract_slide_loop(slide_text)
+                if loop_info:
+                    loop_var, loop_list, loop_type = loop_info
+                    loop_found = True
+
+                    #items = context_dict.get(loop_list, []) or []
+                    items = PptxTemplateEngine._resolve_path(context_dict, loop_list) or []
+
+                    # if loop_type == "of":
+                    #     tracer.log_slide_duplication(idx, len(items))
+                    #     for i, item in enumerate(items):
+                    #         new_slide = PptxTemplateEngine._duplicate_slide(prs, slide)
+                    #         local_context = context_dict.copy()
+                    #         local_context[loop_var] = item
+                    #         render_slide(new_slide, local_context, jinja_env, tracer)
+
+                    #     slides_to_remove.append(slide)
+                    # else:
+                    #     render_slide(slide, context_dict, jinja_env, tracer)
+                    if loop_type == "of":
+                        tracer.log_duplication(idx, len(items), "slide")
+                        for i, item in enumerate(items):
+                            new_slide = PptxTemplateEngine._duplicate_slide(prs, slide)
+                            local_context = context_dict.copy()
+                            local_context[loop_var] = item
+                            # Evita que Jinja procese el 'for of' en la duplicada
+                            PptxTemplateEngine._unwrap_slide_for_blocks(new_slide)
+                            render_slide(new_slide, local_context, jinja_env, tracer)
+
+                        slides_to_remove.append(slide)
+                    else:
+                        render_slide(slide, context_dict, jinja_env, tracer)
+
+                # Si no hay bucle, verificar si hay condicional A NIVEL DE SLIDE
+                elif not loop_found:
+                    conditional_info = extract_slide_conditional_block(slide_text)
+                    if conditional_info:
+                        slide_level_conditional_found = True
+                        try:
+                            if conditional_info['has_block_structure']:
+                                # Bloque condicional completo con if/elif/else
+                                condition_result = evaluate_conditional_block(slide_text, context_dict, jinja_env)
+                                tracer.log_conditional(idx, f"bloque condicional a nivel slide", condition_result)
+                            else:
+                                # Condicional simple
+                                condition = conditional_info['condition']
+                                condition_result = evaluate_condition(condition, context_dict, jinja_env)
+                                tracer.log_conditional(idx, condition, condition_result)
+                            
+                            if condition_result:
+                                # Condición verdadera: renderizar la slide
+                                render_slide(slide, context_dict, jinja_env, tracer)
+                            else:
+                                # Condición falsa: marcar slide para eliminación
+                                slides_to_remove.append(slide)
+                                
+                        except Exception as e:
+                            tracer.log_error(f"Error evaluando condición en slide {idx}: {e}")
+                            # En caso de error, mantener la slide pero sin renderizar
+                            render_slide(slide, context_dict, jinja_env, tracer)
+
+                # Si no hay ni bucle ni condicional A NIVEL DE SLIDE, renderizar normalmente
+                # (los condicionales a nivel de texto se manejan en render_slide)
+                if not loop_found and not slide_level_conditional_found:
+                    render_slide(slide, context_dict, jinja_env, tracer)
+
+            # Remover slides marcadas para eliminación
+            for slide in slides_to_remove:
+                PptxTemplateEngine._remove_slide(prs, slide)
+
+            if output_path:
+                prs.save(output_path)
+                tracer.end()
+                return str(output_path)
+            else:
+                pptx_io = BytesIO()
+                prs.save(pptx_io)
+                pptx_io.seek(0)
+                tracer.end()
+                return pptx_io
+
+        except Exception as e:
+            tracer.log_error(f"Error en render_from_template: {e}")
+            raise RenderError(f"Fallo al renderizar plantilla PPTX: {e}")
+
+    @staticmethod
+    def _duplicate_slide(prs: Presentation, slide: Slide) -> Slide:
+        new_slide = prs.slides.add_slide(slide.slide_layout)
+        for shape in slide.shapes:
+            el = shape.element
+            new_el = deepcopy(el)
+            new_slide.shapes._spTree.insert_element_before(new_el, 'p:extLst')
+        return new_slide
+
+    @staticmethod
+    def _remove_slide(prs: Presentation, slide: Slide):
+        slide_id = slide.slide_id
+        slides = prs.slides._sldIdLst
+        for sld in slides:
+            if sld.get("id") == str(slide_id):
+                slides.remove(sld)
+                break
+
+    @staticmethod
+    def _unwrap_slide_for_blocks(slide: Slide) -> None:
+        """Quita etiquetas {% for ... %}/{% endfor %} in-place sin tocar formato."""
+        start_tag = re.compile(r"""{%\s*for\s+\w+\s+(?:of|in)\s+.+?\s*%}""")
+        end_tag = re.compile(r"""{%\s*endfor\s*%}""")
+        for shape in slide.shapes:
+            if not getattr(shape, "has_text_frame", False):
+                continue
+            tf = shape.text_frame
+            for p in tf.paragraphs:
+                for r in p.runs:
+                    if not r.text:
+                        continue
+                    # Elimina sólo las etiquetas, deja el cuerpo intacto
+                    txt = start_tag.sub("", r.text)
+                    txt = end_tag.sub("", txt)
+                    r.text = txt

stackraise/templating/pptx/slide_renderer.py

@@ -0,0 +1,181 @@
+from pptx.slide import Slide
+from pptx.shapes.base import BaseShape
+from pptx.dml.color import RGBColor
+from stackraise.templating.image.processor import ImageProcessor
+from ..parser import has_image_variables, render_text
+from ..tracer import Tracer
+import re
+
+def remove_for_of_blocks(text: str) -> str:
+    # Desenrolla bucles a nivel de slide: conserva solo el cuerpo
+    #pattern = r"""{%\s*for\s+\w+\s+(?:of|in)\s+\w+\s*%}(.*?){%\s*endfor\s*%}"""
+    pattern = r"""{%\s*for\s+\w+\s+(?:of|in)\s+.+?\s*%}(.*?){%\s*endfor\s*%}"""
+    return re.sub(pattern, r"\1", text, flags=re.DOTALL)
+
+def has_conditional_blocks(text: str) -> bool:
+    """
+    Verifica si el texto contiene bloques condicionales.
+    """
+    pattern = r"""{%\s*if\s+.+?\s*%}"""
+    return bool(re.search(pattern, text))
+
+def has_text_level_loops(text: str) -> bool:
+    """
+    Verifica si el texto contiene bucles que deben procesarse como texto
+    (no como duplicación de slides).
+    """
+    # Buscar bucles que estén mezclados con otro contenido
+    lines = text.strip().split('\n')
+    has_loop = False
+    has_other_content = False
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        #if re.search(r'{%\s*for\s+\w+\s+(of|in)\s+\w+\s*%}', line):
+        if re.search(r'{%\s*for\s+\w+\s+(?:of|in)\s+.+?\s*%}', line):
+            has_loop = True
+        #elif not re.search(r'{%\s*(for|endfor|if|elif|else|endif)\s*.*%}', line):
+        elif not re.search(r'{%\s*(for|endfor|if|elif|else|endif)\s*.*%}', line):
+            has_other_content = True
+    
+    return has_loop and has_other_content
+
+
+def _copy_run_font(dst_run, src_run):
+    try:
+        dst_font = dst_run.font
+        src_font = src_run.font
+        dst_font.name = src_font.name
+        dst_font.size = src_font.size
+        dst_font.bold = src_font.bold
+        dst_font.italic = src_font.italic
+        dst_font.underline = src_font.underline
+        # Color: intenta RGB si existe
+        try:
+            rgb = src_font.color.rgb
+            if rgb is not None:
+                dst_font.color.rgb = RGBColor(rgb[0], rgb[1], rgb[2]) if isinstance(rgb, tuple) else rgb
+        except Exception:
+            try:
+                dst_font.color.theme_color = src_font.color.theme_color
+            except Exception:
+                pass
+    except Exception:
+        pass
+
+def _snapshot_base_style(text_frame):
+    base_para = text_frame.paragraphs[0] if text_frame.paragraphs else None
+    base_run = base_para.runs[0] if (base_para and base_para.runs) else None
+    return base_para, base_run
+
+def write_text_preserving_formatting(text_frame, text: str):
+    # Captura estilo base antes de limpiar
+    base_para_before, base_run_before = _snapshot_base_style(text_frame)
+
+    # Limpia el contenido (deja un párrafo vacío)
+    try:
+        text_frame.clear()
+    except Exception:
+        pass
+
+    lines = (text or "").splitlines() or [""]
+    for idx, line in enumerate(lines):
+        para = text_frame.paragraphs[0] if idx == 0 else text_frame.add_paragraph()
+
+        # Restituye nivel/alineación del párrafo base si existe
+        try:
+            if base_para_before is not None:
+                para.level = base_para_before.level
+                para.alignment = base_para_before.alignment
+        except Exception:
+            pass
+
+        run = para.runs[0] if para.runs else para.add_run()
+        # Copia estilo del run base si existe
+        if base_run_before is not None:
+            _copy_run_font(run, base_run_before)
+        run.text = line
+
+
+def has_only_simple_variables(text: str) -> bool:
+    # Hay variables {{ ... }} pero no bloques {% ... %}
+    return ("{{" in text) and ("{%" not in text)
+
+def render_runs_preserving_formatting(text_frame, context: dict, jinja_env):
+    # Sustituye {{ expr }} dentro de cada run conservando su formato
+    var_re = re.compile(r"\{\{\s*(.*?)\s*\}\}")
+    for paragraph in text_frame.paragraphs:
+        for run in paragraph.runs:
+            original = run.text or ""
+            if not original:
+                continue
+            def repl(m: re.Match) -> str:
+                expr = m.group(1)
+                try:
+                    tpl = jinja_env.from_string("{{ " + expr + " }}")
+                    return str(tpl.render(context))
+                except Exception:
+                    # Si falla, deja el placeholder intacto
+                    return m.group(0)
+            replaced = var_re.sub(repl, original)
+            run.text = replaced
+
+def render_slide(slide: Slide, context: dict, jinja_env, tracer: Tracer):
+    # Primero procesar imágenes (variables ImageData)
+    ImageProcessor.process_slide_images(slide, context, tracer)
+    
+    # Luego procesar texto normal
+    for shape in slide.shapes:
+        if not getattr(shape, "has_text_frame", False):
+            continue
+
+        text_frame = shape.text_frame
+        all_text = ""
+        for paragraph in text_frame.paragraphs:
+            all_text += "".join(run.text for run in paragraph.runs) + "\n"
+
+        try:
+            # Verificar el tipo de contenido
+            has_images = has_image_variables(all_text, context)
+            has_conditionals = has_conditional_blocks(all_text)
+            has_loops = has_text_level_loops(all_text)
+            
+            if has_conditionals or has_loops or has_images:
+                # Si hay condicionales, bucles o imágenes, renderizar TODO con Jinja2
+                # Contenido complejo: render completo (posible pérdida de formatos finos)
+                rendered_text = render_text(all_text, context, jinja_env)
+                write_text_preserving_formatting(text_frame, rendered_text or "")
+                tracer.log_variable(all_text.strip(), (rendered_text or "").strip())
+            else:
+                # Sólo variables simples: sustituir por run conservando formato
+                render_runs_preserving_formatting(text_frame, context, jinja_env)
+                tracer.log_variable(all_text.strip(), (text_frame.text or "").strip())
+
+            # Limpiar el text_frame y agregar el texto renderizado
+            # while len(text_frame.paragraphs) > 1:
+            #     text_frame._element.remove(text_frame._element[-1])
+
+            # paragraph = text_frame.paragraphs[0]
+            # while len(paragraph.runs) > 1:
+            #     paragraph._element.remove(paragraph.runs[-1]._r)
+
+            # paragraph.runs[0].text = rendered_text
+
+                        # Escritura segura: evita IndexError en runs vacíos
+
+            # try:
+            #     text_frame.clear()  # deja un párrafo vacío
+            # except Exception as e:
+            #     print(f"No se pudo limpiar el text_frame: {e}")
+            #     pass
+            # text_frame.text = rendered_text or ""
+
+            write_text_preserving_formatting(text_frame, rendered_text or "")
+            tracer.log_variable(all_text.strip(), (rendered_text or "").strip())
+
+            #tracer.log_variable(all_text.strip(), rendered_text.strip())
+
+        except Exception as e:
+            tracer.log_error(f"Error al renderizar texto '{all_text.strip()}': {e}")

stackraise/templating/tracer.py

@@ -0,0 +1,57 @@
+import logging
+from time import perf_counter
+
+logger = logging.getLogger("pptx_template_engine")
+logger.setLevel(logging.DEBUG)
+handler = logging.StreamHandler()
+formatter = logging.Formatter("[PPTX-TEMPLATE] %(levelname)s - %(message)s")
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
+
+class Tracer:
+    """Tracer genérico para motores de plantillas"""
+    
+    def __init__(self, logger_name: str = "template_engine"):
+        self.start_time = None
+        self.logger = logging.getLogger(logger_name)
+        if not self.logger.handlers:
+            self._setup_logger()
+    
+    def _setup_logger(self):
+        """Configura el logger si no está configurado"""
+        self.logger.setLevel(logging.DEBUG)
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(f"[{self.logger.name.upper()}] %(levelname)s - %(message)s")
+        handler.setFormatter(formatter)
+        self.logger.addHandler(handler)
+
+    def start(self, engine_type: str = "plantilla"):
+        """Inicia el trazado"""
+        self.start_time = perf_counter()
+        self.logger.info(f"Inicio del render de {engine_type}")
+
+    def end(self):
+        """Finaliza el trazado"""
+        duration = perf_counter() - self.start_time
+        self.logger.info(f"Render finalizado en {duration:.2f} segundos")
+
+    def log_variable(self, var: str, value: any):
+        """Registra el renderizado de una variable"""
+        self.logger.debug(f"Variable '{{ {var} }}' → {value}")
+
+    def log_duplication(self, item_idx: int, count: int, item_type: str = "elemento"):
+        """Registra la duplicación de elementos"""
+        self.logger.info(f"{item_type.capitalize()} {item_idx} duplicado {count} veces por bucle")
+
+    def log_conditional(self, item_idx: int, condition: str, result: bool, item_type: str = "elemento"):
+        """Registra la evaluación de condicionales"""
+        self.logger.info(f"Condicional '{condition}' evaluada como {result} en {item_type} {item_idx}")
+
+    def log_error(self, message: str):
+        """Registra un error"""
+        self.logger.error(message)
+
+    def log_info(self, message: str):
+        """Registra información general"""
+        self.logger.info(message)

stackraise-0.1.0.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: stackraise
+Version: 0.1.0
+Summary: 
+Author: J.David Luque
+Author-email: jdluque@leitat.org
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: aioimaplib (>=2.0.1,<3.0.0)
+Requires-Dist: aiosmtplib (>=4.0.1,<5.0.0)
+Requires-Dist: docxtpl (>=0.20.0,<0.21.0)
+Requires-Dist: email-validator (>=2.2.0,<3.0.0)
+Requires-Dist: fastapi[standard] (>=0.115.6,<0.116.0)
+Requires-Dist: inflector (>=3.1.1,<4.0.0)
+Requires-Dist: motor (>=3.6.0,<4.0.0)
+Requires-Dist: openai (>=2.15.0,<3.0.0)
+Requires-Dist: openpyxl (>=3.1.5,<4.0.0)
+Requires-Dist: pydantic (>=2.11,<3.0)
+Requires-Dist: pydantic-settings-yaml (>=0.2.0,<0.3.0)
+Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
+Requires-Dist: pymongo (>=4.13.2,<5.0.0)
+Requires-Dist: pypdf2 (>=3.0.1,<4.0.0)
+Requires-Dist: python-pptx (==1.0.2)
+Requires-Dist: python-slugify (>=8.0.4,<9.0.0)
+Requires-Dist: xlsxtpl (>=0.3.1,<0.4.0)
+Description-Content-Type: text/markdown
+
+# Nothingad backend
+
+```sh
+just bulkload # carga data/workbook.xlsx en la base de datos
+
+just launch # ejecuta el backend
+```

stackraise-0.1.0.dist-info/RECORD

@@ -0,0 +1,52 @@
+stackraise/__init__.py,sha256=T6LUkt1rdxY_zoFU2CgBaEG0bDBLRy6Nf9uv6d6dnKQ,119
+stackraise/ai/__init__.py,sha256=SXz7CzvgQHiAbnsFvyKBsTmH1QpuXrlZg3o2kDQHLbw,41
+stackraise/ai/rpa.py,sha256=sSZTpW_OlsOR2312cI-ttuh9GsggZoyXxJOZyZY2CT4,12371
+stackraise/ai/toolset.py,sha256=iOIpuin_hpR6WGjj1DqHme2Lb-0HEba-lW-cIOwkCR8,6997
+stackraise/app.py,sha256=toyeotSU_XL2U0Se8mCtp8tM61omehs34jFoBzV52L8,631
+stackraise/auth/__init__.py,sha256=MzHWdMbPciCE17HfZx_Irr-lax8swtL85W_IubFqIGY,64
+stackraise/auth/model.py,sha256=biudWx1IrwvwCgW5R6Hl0VTUPuQpk10my03qYj2SKAM,679
+stackraise/auth/service.py,sha256=A20CwObI3VCXHBuX5eGnzHOiNgD1UhYeOL65aSPGCWw,7783
+stackraise/ctrl/__init__.py,sha256=IDIG0MsDc8nxguMFttkqE_cQtH-FdMull4xd52ypVfo,99
+stackraise/ctrl/change_stream.py,sha256=6QFp_Z1WL168p3IzFeu4mNJ2USaThPp-Qk7JRrxYb68,1180
+stackraise/ctrl/crud_controller.py,sha256=YjN8RiimGfL_sISzjgwl0hjPNqOOmj4AtNPdTaL1-fA,2123
+stackraise/ctrl/file_storage.py,sha256=MZnD45j4DCXVEpS1ricgjLw2-3dQ0NEloCOEUSVODBA,2262
+stackraise/db/__init__.py,sha256=whU36yRPuwhQ45r9H493NCtJZsmkoU1AaDfK1401Bf0,272
+stackraise/db/adapter.py,sha256=wQTbC1m7KKhKl31p847gnqYtVkfMBJR1g2Rj1UF6D78,1570
+stackraise/db/collection.py,sha256=pGd2VrZ06El5e-HnT_Y2rQpbGz6JTD5KJGh7iL65BZ4,10752
+stackraise/db/cursor.py,sha256=CBg2FutsGplst5g3F0UKYloaQC4i_7vq0h9qPicc_ZE,6504
+stackraise/db/document.py,sha256=k1_7qNW9rhbpHK6VQcKmJKhuf9mEHDQB-umpP1P4OH8,9444
+stackraise/db/exceptions.py,sha256=ICrWbW3IsZIOYS0OTI9RROmkmOeAlqKlOLQyNvF3Q-0,308
+stackraise/db/id.py,sha256=cJl45y4HmtpAAVXasnmVtCIRB-gkuHexAAVNzHHF2Es,2426
+stackraise/db/index.py,sha256=UeSa_eAkx2m_eVN2fOnjectXnnqp1tg_36tynDrabBM,2735
+stackraise/db/persistence.py,sha256=qmB1371cluPBdtbJnYbMzFHCODxFDfob07PUe_trEjY,6776
+stackraise/db/pipeline.py,sha256=qthH3b8rvE71r909RABpUpvJVDqyKhKQdrAvDpVX3HE,7223
+stackraise/db/protocols.py,sha256=HCC3ic2MI47wpHJnYbFxwpXaJK2aPgMa9Q0sKGKqAoE,4545
+stackraise/di.py,sha256=eg-nG0GtQZsFs6xyQ3ZKx5sY3EG6TQPe5N8rq8MMixc,921
+stackraise/event.py,sha256=e-B-FYvyZN7xcv9ELOBlfDTrNsEh8taTEKoMDN4FZDQ,4184
+stackraise/inflection.py,sha256=aHPU69PKs9qmv2L4HdY04Uqq6kqPBYa1k6gCKd0OZIo,542
+stackraise/io/__init__.py,sha256=NZn3USTIx9jUAJ0J-KR63wm3HCqErGAl-oUwjgezoW4,84
+stackraise/io/imap_client.py,sha256=zJDdgFqvCsq2IPon9Fs3qbKJSiqfw9D7-s54Wc5T-Po,15096
+stackraise/io/smtp_client.py,sha256=9BCHWPb2hvXhRINPbkX43GbIgLDSZicfWJaV0SXenH0,3243
+stackraise/logging.py,sha256=aAgognVCEjCMuhaApBKBGyc13TKnsRgYu9STIJUzLbY,470
+stackraise/model/__init__.py,sha256=iyO_Q8Pnl-6UQCTV4IrZFx1N1TyeT8TX5TsbINM6OCs,261
+stackraise/model/core.py,sha256=v9TpsUtQucvv9P1jB6NBcb2d4_S0mooujAt0rcbsHcM,415
+stackraise/model/dto.py,sha256=SGm6JZ8JwW27iX5v4Ou7D-b73WpZY9Cb49PxdqK6yNs,277
+stackraise/model/email_message.py,sha256=qZgj4HgLARrwNd34vW27lL5A9PBN1nl6MSZcwEbFnN4,2003
+stackraise/model/file.py,sha256=Fb1yYpQbUgfL0HkJ9YEw0BpqJcpxDIMNKyD0TCYZh-w,5019
+stackraise/model/name_email.py,sha256=_X9QCTqPOA977wvzZzObIHyIZNib63zpE4IKzYfeq5U,1408
+stackraise/model/query_filters.py,sha256=1m25avpPIFPWJ6e_MVS0ilFtTEKUSp4JqGeq1RlpQDM,7391
+stackraise/model/time_range.py,sha256=2uy7ik6u7W-AQT2ZPqIvVPRcMe4uryC94gSnz4awJWQ,8703
+stackraise/model/validation.py,sha256=jdqVutwc7M7qjdtv8VKkYpCpyqSHWe2xSx0sNp1WT3o,255
+stackraise/templating/__init__.py,sha256=S6Na4oFzHdxWM1YKzdPbUHMqeEHNXFjdCr5iHp_AsdI,84
+stackraise/templating/exceptions.py,sha256=MlR9bw6SNu5Incd9CrHgz7iBPCWaAh6sL-efaxE_L0Q,412
+stackraise/templating/image/__init__.py,sha256=jk_WNdl-lg8bGUpFxRhU4nZ7tmmvsxne1KFoX42H9rM,45
+stackraise/templating/image/model.py,sha256=Bk0sGN7mdrgw7bg8YFf8HOhjJbivdmeo1NG-wvC9FZ0,1959
+stackraise/templating/image/processor.py,sha256=Lz6xFXxXvcsdpD7EeaeWbUYD-Z9HZHQRBxWQ5jVpMQ0,6697
+stackraise/templating/parser.py,sha256=5jmBFtn4hkrm8SfLc-fFTqIE2mJmNCqnYf3r7BGSg0Y,5743
+stackraise/templating/pptx/__init__.py,sha256=nfC9DiY6QWGZ83grgInEYbTgZDKBu2DqOlWjSTk_bd8,83
+stackraise/templating/pptx/pptx_engine.py,sha256=Ykb25fkJSvYrAzADPVSgQ_R6v558JzJETkpbo8wTz68,8916
+stackraise/templating/pptx/slide_renderer.py,sha256=5jGisi-_Fy8iTGgszGRObTbqzaOKD_5LdzLw8uEil0E,7149
+stackraise/templating/tracer.py,sha256=tJdBHWDyRVnAgtES26t26elgx8DdNVZKhAnP-ts0FhY,2214
+stackraise-0.1.0.dist-info/METADATA,sha256=zXm3qLkPezeeA8W18ZG3CbTVE6tlkffo53divcuejwI,1243
+stackraise-0.1.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+stackraise-0.1.0.dist-info/RECORD,,

stackraise-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any