pydocmaker 1.0.0__tar.gz

pydocmaker-1.0.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: pydocmaker
+Version: 1.0.0
+Summary: a minimal document maker to make docx, markdown, html, and tex documents from python. Written in pure python.
+Home-page: https://github.com/TobiasGlaubach/pyandoc
+Author: Tobias Glaubach
+Project-URL: Bug Tracker, https://github.com/TobiasGlaubach/pyandoc/issues
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# pydocmaker
+a minimal document maker to make docx, markdown, html, and tex documents from python.
+Written in pure python. 
+
+Named in honor and spirit after the famous [pandoc](https://github.com/jgm/pandoc) package.

pydocmaker-1.0.0/README.md

@@ -0,0 +1,5 @@
+# pydocmaker
+a minimal document maker to make docx, markdown, html, and tex documents from python.
+Written in pure python. 
+
+Named in honor and spirit after the famous [pandoc](https://github.com/jgm/pandoc) package.

pydocmaker-1.0.0/setup.cfg

@@ -0,0 +1,33 @@
+[metadata]
+name = pydocmaker
+description-file = README.md
+license_files = LICENSE.rst
+author = Tobias Glaubach
+description = a minimal document maker to make docx, markdown, html, and tex documents from python. Written in pure python.
+license_file = LICENSE
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/TobiasGlaubach/pyandoc
+project_urls = 
+	Bug Tracker = https://github.com/TobiasGlaubach/pyandoc/issues
+classifiers = 
+	License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+	Operating System :: OS Independent
+	Environment :: Console
+	Programming Language :: Python
+	Programming Language :: Python :: 3
+	Programming Language :: Python :: 3 :: Only
+
+[options]
+package_dir = 
+	=src
+packages = find:
+python_requires = >=3.8
+
+[options.packages.find]
+where = src
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

pydocmaker-1.0.0/setup.py

@@ -0,0 +1,10 @@
+
+import re
+
+def get_property(prop, project):
+    with open('src/' + project + '/__init__.py') as fp:
+        result = re.search(r'{}\s*=\s*[\'"]([^\'"]*)[\'"]'.format(prop), fp.read())
+    return result.group(1)
+
+# print(get_property('__version__', "mke_client"))
+from setuptools import setup; setup(version=get_property('__version__', "pydocmaker"))

pydocmaker-1.0.0/src/pydocmaker/__init__.py

@@ -0,0 +1,12 @@
+__version__ = '1.0.0'
+
+from pyandoc.core.schema import c as constr
+
+from pyandoc.core.schema import FlowDoc, SectionedDoc, construct, dump
+
+from pyandoc.exporters.ex_docx import convert as to_docx
+from pyandoc.exporters.ex_html import convert as to_html
+from pyandoc.exporters.ex_redmine import convert as to_redmine
+from pyandoc.exporters.ex_redmine import convert as to_textile
+from pyandoc.exporters.ex_tex import convert as to_tex
+

pydocmaker-1.0.0/src/pydocmaker/core/schema.py

@@ -0,0 +1,148 @@
+from dataclasses import dataclass, field, is_dataclass
+from collections import UserDict, UserList
+
+
+
+
+
+class c():
+    """This is the basic schema for the main building blocks for a document"""
+
+    @staticmethod
+    def markdown(children=''):
+        return {
+            'typ': 'markdown',
+            'children': children
+        }
+    
+    @staticmethod
+    def text(children=''):
+        return {
+            'typ': 'text',
+            'children': children
+        }
+    
+    @staticmethod
+    def verbatim(children=''):
+        return {
+            'typ': 'verbatim',
+            'children': children
+        }
+    
+    @staticmethod
+    def iter(children:list=None):
+        return {
+            'typ': 'iter',
+            'children': [] if children is None else children,
+        }
+    
+    @staticmethod
+    def image(imageblob='', caption='', children='', width=0.8):
+        return {
+            'typ': 'image',
+            'children': children,
+            'imageblob': imageblob.decode("utf-8") if isinstance(imageblob, bytes) else imageblob,
+            'caption': caption,
+            'width': width,
+        }
+    
+
+
+class FlowDoc(UserList):
+    """an unordered collection of document parts to make a document (can be used like a list)"""
+
+    def add(self, element_to_add:dict={}):
+        
+        assert element_to_add, 'need to give an element_to_add!'
+        assert hasattr(c, element_to_add.get('typ', None)), 'the element to add is of unknown type!'
+        self.append(element_to_add)
+            
+    def add_kw(self, typ='', **kwargs):
+        assert typ, 'need to give a content type!'
+        self.add(construct(typ, **kwargs))
+
+    def dump(self):
+        return [dump(v) for v in self]
+
+class SectionedDoc(UserDict):
+    """a sectioned collection of document parts to make a document (can be used like a dict)"""
+
+    def add_section(self, caption, children:list=None):
+        assert caption, 'need to give a caption!'
+        assert not caption in self, f'section with {caption=} already exists in Document'
+        assert children is None or isinstance(children, list), 'children must be of type list or None'
+        self[caption] = [] if children is None else children
+
+    def add(self, section_caption:str=None, element_to_add:dict={}):
+        if not section_caption and len(self):
+            section_caption = list(self.keys())[-1]
+        
+        assert section_caption, 'need to give a section_caption to add to!'
+        assert element_to_add, 'need to give an element_to_add!'
+        assert hasattr(c, element_to_add.get('typ', None)), 'the element to add is of unknown type!'
+        if not section_caption in self:
+            self.add_section(caption=section_caption)
+        self[section_caption].append(element_to_add)
+            
+    def add_kw(self, section_caption=None, typ='', **kwargs):
+        assert typ, 'need to give a content type!'
+        self.add(section_caption, construct(typ, **kwargs))
+
+    def to_flow_doc(self):
+        doc = FlowDoc()
+        for section_caption, section_parts in self.items():
+            doc.add(c.markdown(f'## {section_caption}'))
+            for part in section_parts:
+                doc.add(part)
+        return doc
+    
+    def dump(self):
+        return self.to_flow_doc().dump()
+
+
+def _serialize(v):
+    if isinstance(v, str):
+        return v
+    elif isinstance(v, list):
+        return [dump(vv) for vv in v]
+    elif isinstance(v, dict):
+        return v
+    else:
+        TypeError(f'{type(v)=} is of unknown type only dataclass, str, list, and dict is allowed!')
+
+
+def _construct(v):
+
+    if isinstance(v, str):
+        return v
+    elif isinstance(v, list):
+        return [_construct(vv) for vv in v]
+    elif isinstance(v, dict):
+        return construct(**v)
+    else:
+        TypeError(f'{type(v)=} is of unknown type only dataclass, str, list, and dict is allowed!')
+
+def construct(type:str, **kwargs):
+    assert isinstance(type, str)
+    if not kwargs and not hasattr(c, type):
+        return type
+    elif hasattr(c, type):
+        children = kwargs.get('children')
+        if children:
+            kwargs['children'] = _construct(children)
+        constructor = getattr(c, type)
+        return constructor(**kwargs)
+    else:
+        TypeError(f'{type=} is of unknown type only dataclass, str, list, and dict is allowed!')
+
+def dump(obj):
+    if isinstance(obj, list):
+        return [dump(o) for o in obj]
+    
+    assert isinstance(obj, dict)
+    return {k:_serialize(v) for k, v in obj.items()}
+
+
+if __name__ == "__main__":
+    mysection = c.markdown('# Introduction')
+

pydocmaker-1.0.0/src/pydocmaker/exporters/ex_docx.py

@@ -0,0 +1,146 @@
+import traceback
+import io
+
+import base64
+from typing import List
+
+import docx
+from docx.shared import Inches, Pt
+
+
+import markdown
+
+        
+def blue(run):
+    run.font.color.rgb = docx.shared.RGBColor(0, 0, 255)
+
+def red(run):
+    run.font.color.rgb = docx.shared.RGBColor(255, 0, 0)
+
+def convert(doc:List[dict]) -> bytes:
+    renderer = docx_renderer()
+    renderer.digest(doc)
+    return renderer.doc_to_bytes()
+
+class docx_renderer():
+    def __init__(self, template_path:str=None, make_blue=False) -> None:
+        self.d = docx.Document(template_path)
+        self.make_blue = make_blue
+
+    def add_paragraph(self, newtext, *args, **kwargs):
+        new_paragraph = self.d.add_paragraph(newtext, *args, **kwargs)
+        if self.make_blue:
+            for r in new_paragraph.runs:
+                blue(r)
+        return new_paragraph
+    
+    def add_run(self, text, *args, **kwargs):
+        if not self.d.paragraphs:
+            self.add_paragraph('')
+
+        last_paragraph = self.d.paragraphs[-1]
+        
+        if not last_paragraph.runs:
+            last_run = last_paragraph.add_run(text)
+        else:
+            last_run = last_paragraph.runs[-1]
+            last_run.add_text(text)
+            
+        if self.make_blue:
+            blue(last_run)
+        return last_run
+        
+    def digest_text(self, children, *args, **kwargs):
+        return self.add_paragraph(children)
+    
+
+    def digest_str(self, children, *args, **kwargs):
+        return self.add_run(children)
+
+    def digest_markdown(self, children, *args, **kwargs):
+        return self.add_paragraph(children, style='Normal')
+        
+    def digest_verbatim(self, children, *args, **kwargs):
+        new_run = self.add_run(children)
+        new_run.font.name = 'Courier New'  # Or any other monospace font
+        new_run.font.size = docx.shared.Pt(8)  # Adjust font size as needed
+        return new_run
+
+
+    def digest_error(self, children, *args, **kwargs):
+        if isinstance(children, BaseException):
+            traceback.print_exc(limit=5)
+            children = traceback.format_exc(limit=5)
+
+        new_run = self.add_run(children)
+        new_run.font.name = 'Courier New'  # Or any other monospace font
+        new_run.font.size = docx.shared.Pt(8)  # Adjust font size as needed
+        red(new_run)
+        return new_run
+
+
+    def digest_iterator(self, children, *args, **kwargs):
+        if children:
+            return [self.digest(val, *args, **kwargs) for val in children]
+        return []
+
+
+    def digest_image(self, children, *args, **kwargs):
+
+        image_width = Inches(max(1, kwargs.get('width', 0.8)*5))
+        image_caption = kwargs.get('caption', '')
+        image_blob = kwargs.get('imageblob', '')
+
+        assert image_blob, 'no image data given!'
+
+        # Decode the base64 image
+        img_bytes = base64.b64decode(image_blob)
+
+        # Create an image stream from the bytes
+        image_stream = io.BytesIO(img_bytes)
+        
+        picture = self.d.add_picture(image_stream, width=image_width)
+        # picture.width = image_width  # Ensure fixed width
+        # picture.height = None  # Adjust height automatically
+        picture.alignment = 1
+
+        run = self.add_paragraph(image_caption)
+        # run.style = 'Caption'  # Apply the 'Caption' style for formatting
+
+        return run
+
+    def digest(self, children, *args, **kwargs):
+        try:
+            print(f'{type(children)=}, {args=} {kwargs=}')
+            if not children:
+                return ''
+            elif isinstance(children, str):
+                ret = self.digest_str(children, *args, **kwargs)
+            elif isinstance(children, dict) and 'typ' in children and children['typ'] == 'iter':
+                ret = self.digest_iterator(children, *args, **kwargs)
+            elif isinstance(children, list) and children:
+                ret = self.digest_iterator(children, *args, **kwargs)
+            elif isinstance(children, dict) and 'typ' in children and children['typ'] == 'image':
+                ret = self.digest_image(*args, **kwargs, **children)
+            elif isinstance(children, dict) and 'typ' in children and children['typ'] == 'text':
+                ret = self.digest_text(*args, **kwargs, **children)
+            elif isinstance(children, dict) and 'typ' in children and children['typ'] == 'verbatim':
+                ret = self.digest_verbatim(*args, **kwargs, **children)
+            elif isinstance(children, dict) and 'typ' in children and children['typ'] == 'markdown':
+                ret = self.digest_markdown(*args, **kwargs, **children)
+            else:
+                val = f'the element of type {type(children)}, could not be parsed.'
+                ret = self.digest_error(val, *args, **kwargs)
+        except Exception as err:
+            ret = self.digest_error(err, *args, **kwargs)
+
+        return ret
+
+    def doc_to_bytes(self):
+        with io.BytesIO() as fp:
+            self.d.save(fp)
+            fp.seek(0)
+            return fp.read()
+
+    def save(self, filepath):
+        self.d.save(filepath)

pydocmaker-1.0.0/src/pydocmaker/exporters/ex_html.py

@@ -0,0 +1,207 @@
+from collections import namedtuple
+import io
+import json
+import random
+import textwrap
+import time
+import urllib
+import re
+import uuid
+import os
+import base64
+import markdown
+from typing import List
+
+
+"""
+
+ ██████  ██████  ███    ██ ██    ██ ███████ ██████  ████████ 
+██      ██    ██ ████   ██ ██    ██ ██      ██   ██    ██    
+██      ██    ██ ██ ██  ██ ██    ██ █████   ██████     ██    
+██      ██    ██ ██  ██ ██  ██  ██  ██      ██   ██    ██    
+ ██████  ██████  ██   ████   ████   ███████ ██   ██    ██    
+                                                             
+                                                                                                                                                                                                                                       
+"""
+
+# DEFAULT_IMAGE_PATH = os.path.join(parent_dir, 'ReqTracker', 'assets', 'mpifr.png')
+# with open(DEFAULT_IMAGE_PATH, 'rb') as fp:
+#     DEFAULT_IMAGE_BLOB = '' # base64.b64encode(fp.read()).decode('utf-8')
+# DEFAULT_IMAGE_BLOB = ''
+
+def mk_link(id_, label=None, pth='show', p0='uib', v='v1', **kwargs):
+    return f'<a href="/{p0}/{v}/{pth}/{urllib.parse.quote_plus(id_)}" target="_self">{label if label else id_}</a>'
+
+def mk_tpl(id_, label=None, pth='show', p0='uib', v='v1', **kwargs):
+    return f"/{p0}/{v}/{pth}/{urllib.parse.quote_plus(id_)}", label if label else id_
+
+
+def convert(doc:List[dict]):
+    tmp = doc.values() if isinstance(doc, dict) else doc
+    return '\n\n'.join([html_docdc2html(dc) for dc in tmp])
+
+
+class html_renderer:
+
+    @staticmethod
+    def vm_Text(**kwargs):
+        label = kwargs.get('label', '')
+        content = kwargs.get('content', kwargs.get('children'))
+    
+        if label:
+            return f'<div style="min-width:100">{label}</div><div>{content}</div>'
+        else:
+            return f'<div>{content}</div>'
+            
+    @staticmethod
+    def vm_Markdown(**kwargs):
+        label = kwargs.get('label', '')
+        content = kwargs.get('content', kwargs.get('children'))
+
+        parts = []
+        if label:
+            parts += [
+                f'<div style="min-width:100;">{label}</div>',
+                '<hr/>'
+            ]
+        
+        s = markdown.markdown(content)
+        
+        # s = f'<pre disabled=true style="width:90%; min-height:200px; overflow-x: scroll; overflow-y: none; margin:5px;display:block;font-family: Lucida Console, Courier New, monospace;font-size: 0.8em;">\n\n{content}\n\n</pre>'
+        #s = f'<span style="display:block;" class="note">\n\n{content}\n\n</span>'
+        parts += [s]
+
+        return '\n\n'.join(parts)
+    
+
+    @staticmethod
+    def vm_LargeText(**kwargs):
+        label = kwargs.get('label', '')
+        content = kwargs.get('content', kwargs.get('children'))
+    
+        nn = [len(s) for s in content.split('\n')]
+        n = len(n)
+        w = max(nn)
+        return f'<div style="min-width:100;">{label}</div><hr></hr>\n\n<textarea cols="{w}" rows="{n}" disabled=True>\n\n{content}\n\n</textarea>'
+    
+
+    @staticmethod
+    def vm_Iterator(**kwargs):
+        children = []
+        content = kwargs.get('content', kwargs.get('children'))
+        for i, c in enumerate(content, 1):
+            children.append(c.to_html(add_header=False) if hasattr(c, 'get_VM') else c)
+
+        return f'\n\n'.join([f'<div>{c}</div>' for c in children])
+    
+
+
+    @staticmethod
+    def vm_BaseFallback(**kwargs):
+        label = kwargs.get('label', '')
+        content = kwargs.get('content', kwargs.get('children'))
+    
+        j = '#!/RAWJSON!\n' + json.dumps(content, indent=2)
+        nn = [len(s) for s in j.split('\n')]
+        n = len(n)
+        w = max(nn)
+        return f'<div style="min-width:100;">{label}</div><hr></hr>\n\n<textarea cols="{w}" rows="{n}" disabled=True>\n\n{j}\n\n</textarea>'
+    
+
+    @staticmethod
+    def vm_Verbatim(**kwargs):
+        label = kwargs.get('label', '')
+        content = kwargs.get('content', kwargs.get('children'))
+
+        j = content
+        nn = [len(s) for s in j.split('\n')]
+        n = len(n)
+        w = max(nn)
+        children = [
+            f'<div style="min-width:100;">{label}</div>',
+            f'<textarea cols="{w}" rows="{n}" disabled=True>\n\n{j}\n\n</textarea>'
+        ]
+        return '\n\n'.join(children)
+
+    @staticmethod
+    def vm_Image(label='', imageblob=None, children='', width=0.8, caption="", **kwargs):       
+        
+        if imageblob is None:
+            imageblob = ''
+
+        uid = (id(imageblob) + int(time.time()) + random.randint(1, 100))
+
+
+        if not children:
+            children = f'image_{uid}.png'
+
+        s = imageblob.decode("utf-8") if isinstance(imageblob, bytes) else imageblob
+        if not s.startswith('data:image'):
+            s = 'data:image/png;base64,' + s
+        
+
+        children = [
+            f'<div style="min-width:100;">{label}</div>',
+            f'<div style="min-width:100;">image-name:</div>',
+            f'<div>{children}</div>',
+            f'<div style="min-width:100;">width</div>',
+            f'<div>{width}</div>',
+            f'<div style="min-width:100;">caption</div>',
+            f'<div>{caption}</div>',
+            f"<image src=\"{s}\", style=\"max-width:80%\"></image>",
+            ]
+        
+        # children = dcc.Upload(id=self.mkid('helper_uploadfile'), children=children, multiple=False, disable_click=True)
+
+        return '\n\n'.join(children)
+
+    @staticmethod
+    def vm_BaseFallback(**kwargs):
+        label = kwargs.get('label', '')
+        content = kwargs.get('content', kwargs.get('children'))
+    
+        j = '#!/RAWJSON!\n' + json.dumps(content, indent=2)
+        nn = [len(s) for s in j.split('\n')]
+        n = len(n)
+        w = max(nn)
+        return f'<div style="min-width:100;">{label}</div><hr></hr>\n\n<textarea cols="{w}" rows="{n}" disabled=True>\n\n{j}\n\n</textarea>'
+    
+    @staticmethod
+    def vm_Iterator( **kwargs):
+        label = kwargs.get('label', '')
+        content = kwargs.get('content', kwargs.get('children'))
+        return f'\n\n'.join([f'<div>{c}</div>' for c in content])
+    
+    @staticmethod
+    def vm_LargeText(**kwargs):
+        label = kwargs.get('label', '')
+        content = kwargs.get('content', kwargs.get('children'))
+        nn = [len(s) for s in content.split('\n')]
+        n = len(n)
+        w = max(nn)
+        return f'<div style="min-width:100;">{label}</div><hr></hr>\n\n<textarea cols="{w}" rows="{n}" disabled=True>\n\n{content}\n\n</textarea>'
+    
+
+
+def html_docdc2html(content):
+
+    if isinstance(content, str):
+        return html_renderer.vm_Text(content=content)
+    elif isinstance(content, dict) and content.get('typ', None) == 'iter' and isinstance(content.get('children', None), list):
+        return html_renderer.vm_Iterator(content=[html_docdc2html(c) for c in content.get('children')])
+    elif isinstance(content, list):
+        return html_renderer.vm_Iterator(content=[html_docdc2html(c) for c in content])
+    elif isinstance(content, dict) and content.get('typ', None) == 'image':
+        return html_renderer.vm_Image(**content)
+    elif isinstance(content, dict) and content.get('typ', None) == 'text':
+        return html_renderer.vm_Text(**content) 
+    elif isinstance(content, dict) and content.get('typ', None) == 'verbatim':
+        return html_renderer.vm_Verbatim(**content) 
+    elif isinstance(content, dict) and content.get('typ', None) == 'markdown':
+        return html_renderer.vm_Markdown(**content) 
+    else:
+        raise TypeError(f'the element of type {type(content)}, could not be parsed.', content)
+    
+
+
+

pydocmaker-1.0.0/src/pydocmaker/exporters/ex_redmine.py

@@ -0,0 +1,175 @@
+import yaml, base64, time, io, copy, json, traceback, hashlib, markdown, re
+from typing import List
+
+def doc2attachment(doc_dc):
+    content = io.BytesIO(bytes(json.dumps(doc_dc, indent=2), 'ascii'))
+    return {"path" : content, "filename" : 'doc_dict.json', "content_type" : "application/octet-stream"}
+
+def bindoc2attachment(mybytes, filename):
+    content = io.BytesIO(mybytes)
+    return {"path" : content, "filename" : filename, "content_type" : "application/octet-stream"}
+
+
+def convert(doc:List[dict], with_attachments=True, files_to_upload=None):
+
+    files_to_upload = {} if not files_to_upload else files_to_upload
+
+    formatter = DocumentRedmineFormatter()
+    s = formatter.digest(doc)
+    text = '\n'.join(s)
+    if with_attachments:
+        attachments = [doc2attachment(doc)]
+        attachments += formatter.attachments 
+        attachments += [bindoc2attachment(bts, k) for k, bts in files_to_upload.items()]
+        return text, attachments
+    else:
+        return text
+    
+
+def im2attachment(dc_img):
+    mapper = {
+            '/' : 'jpg',
+            'i' : 'png',
+            'R' : 'gif',
+            'U' : 'webp'
+        }
+    filename = dc_img.get('children', None)
+    imageblob = dc_img.get('imageblob')
+
+    if not filename: 
+        if ';base64' in imageblob:
+            ext = imageblob.split(';base64')[0].split('/')[-1]
+        elif mapper.get(imageblob[0], None):
+            ext = mapper.get(imageblob[0], None)
+        else:
+            raise KeyError('extension could not be determined from imageblob')
+
+        #filename = f'img_{time.time_ns()}_{str(id(dc))[-4:]}.{ext}'
+        filename = f"img_{hashlib.md5(imageblob.encode('utf-8')).hexdigest()}.{ext}"
+    description = dc_img.get('caption', '')
+    if not description: 
+        description = filename
+    
+    content = io.BytesIO(base64.b64decode(imageblob))
+
+    return {"path" : content, "filename" : filename, "content_type" : "application/octet-stream", "description": description}
+
+
+class DocumentRedmineFormatter:
+
+    def __init__(self, out_format='textile') -> None:
+        self.attachments = []
+        self.out_format = out_format
+
+    def handle_error(self, err, el) -> list:
+        txt = 'ERROR WHILE HANDLING ELEMENT:\n{}\n\n'.format(el)
+        if not isinstance(err, str):
+            txt += '\n'.join(traceback.format_exception(err, limit=5)) + '\n'
+        else:
+            txt += err + '\n'
+        txt = f"""<pre>\n{txt}\n</pre>"""
+
+        return [txt]
+
+    def digest_text(self, children='', **kwargs) -> list:
+        return [children]
+
+    def digest_markdown(self, children='', **kwargs) -> list:
+        return [children]
+    
+    def digest_image(self, **kwargs) -> list:
+        attachment = im2attachment(kwargs)
+
+        filename = attachment.get('filename')
+        caption = attachment.get('description')
+        self.attachments.append(attachment)
+        s = f'!{filename}({caption})!\n**IMAGE:** attachment:"{filename}" {caption}\n'
+        return [s]
+    
+    def digest_text(self, children='', **kwargs) -> list:
+        return [children]
+
+
+    def digest_verbatim(self, children='', **kwargs) -> list:
+        txt = self.digest(children).strip('\n')
+        s = f"""<pre>{txt}</pre>"""
+        return [s]
+
+
+    def digest_iter(self, el) -> list:
+        parts = []
+        if isinstance(el, dict) and el.get('typ', '') == 'iter' and isinstance(el.get('children', None), list):
+            el = el['children']
+        
+        assert isinstance(el, list)
+        for p in el:
+            parts += self.digest(p)
+            parts.append('\n\n')
+
+        return parts
+    
+    def parse_md2html(self, s) -> str:
+        return markdown.markdown(s, extensions=['extra', 'toc'])
+
+    def parse_md2textile_line(self, line):
+        r = re.match(r'([ \t]*)#+', line)
+        n = r.group().count('#') if r else None
+        if n:
+            line = re.sub(r'([ \t]*)#+', rf'\1h{n}. ', line)
+
+        r = re.match(r'^([ \t]*-{1}[ ]{1})', line)
+        if r:
+            g = r.group()
+            line = line.replace(g, ('*'*len(g)) + ' ')
+
+        return line
+
+    
+
+    def parse_md2textile(self, s) -> str:
+        f = self.parse_md2textile_line
+        lines = [f(line) for line in s.split('\n')]
+        s = '\n'.join(lines)
+        # code blocks
+        s = re.sub(r"(```)([\s\S]*?)(?=```)(```)", r'<pre>\2</pre>', s)
+
+        # links
+        s = re.sub(r"(\[)([\s\S]*?)(?=\])(\])(\()([\s\S]*?)(?=\))(\))", r'"\2":\5', s)
+        
+        return s
+
+    def digest_str(self, el) -> list:
+        return [el]
+        
+    def digest(self, el) -> list:
+        try:
+            
+            if not el:
+                return ''
+            elif isinstance(el, str):
+                ret = self.digest_str(el)
+            elif isinstance(el, dict) and 'typ' in el and el['typ'] == 'iter':
+                ret = self.digest_iter(el)
+            elif isinstance(el, list) and el:
+                ret = self.digest_iter(el)
+            elif isinstance(el, dict) and 'typ' in el and el['typ'] == 'image':
+                ret = self.digest_image(**el)
+            elif isinstance(el, dict) and 'typ' in el and el['typ'] == 'text':
+                ret = self.digest_text(**el)
+            elif isinstance(el, dict) and 'typ' in el and el['typ'] == 'verbatim':
+                ret = self.digest_verbatim(**el)
+            elif isinstance(el, dict) and 'typ' in el and el['typ'] == 'markdown':
+                ret = self.digest_markdown(**el)
+            else:
+                return self.handle_error(f'the element of type {type(el)} {el=}, could not be parsed.')
+            
+            if self.out_format == 'html':
+                ret = [self.parse_md2html(s) for s in ret]
+            elif self.out_format == 'textile':
+                ret = [self.parse_md2textile(s) for s in ret]
+
+            return ret
+        
+        except Exception as err:
+            return self.handle_error(err, el)
+

pydocmaker-1.0.0/src/pydocmaker/exporters/ex_tex.py

@@ -0,0 +1,202 @@
+
+import argparse
+import base64
+import os
+import re
+from pathlib import Path
+import json
+import shutil
+import traceback
+import sys
+
+import tempfile
+import shutil
+from io import BytesIO
+
+from dataclasses import dataclass
+import zipfile
+
+from typing import List
+import markdown
+try:
+    import pyandoc.sub.mdx_latex as mdx_latex
+except Exception as err:
+    from ..sub import mdx_latex
+
+md = markdown.Markdown()
+latex_mdx = mdx_latex.LaTeXExtension()
+latex_mdx.extendMarkdown(md)
+
+
+
+
+
+
+def convert(doc:List[dict], with_attachments=True, files_to_upload=None):
+
+    files_to_upload = {} if not files_to_upload else files_to_upload
+
+    formatter = ElementFormatter()
+    s = formatter.format(doc)
+    text = '\n'.join(s)
+    if with_attachments:
+        return text, formatter.attachments
+    else:
+        return text
+    
+
+
+
+
+###########################################################################################
+"""
+
+███████  ██████  ██████  ███    ███  █████  ████████ 
+██      ██    ██ ██   ██ ████  ████ ██   ██    ██    
+█████   ██    ██ ██████  ██ ████ ██ ███████    ██    
+██      ██    ██ ██   ██ ██  ██  ██ ██   ██    ██    
+██       ██████  ██   ██ ██      ██ ██   ██    ██    
+                                                     
+"""
+###########################################################################################
+
+
+class ElementFormatter:
+
+    def __init__(self, make_blue=False) -> None:
+        self.attachments = {}
+        self.make_blue = make_blue
+
+
+    def handle_error(self, err, el):
+        txt = 'ERROR WHILE HANDLING ELEMENT:\n{}\n\n'.format(el)
+        if not isinstance(err, str):
+            txt += '\n'.join(traceback.format_exception(err, limit=5)) + '\n'
+        else:
+            txt += err + '\n'
+        txt = r"""
+\begin{verbatim}
+
+<REPLACEME:VERBTEXT>
+
+\end{verbatim}""".replace('<REPLACEME:VERBTEXT>', txt)
+        txt = f'{{\\color{{red}}{txt}}}'
+
+        return txt
+
+    def digest_markdown(self, children='', **kwargs) -> str:
+        tex = md.convert(children).lstrip('<root>').rstrip('</root>')
+        return tex
+
+    
+    def digest_image(self, children='', width=0.8, caption='', imageblob='', **kwargs) -> str:
+
+        if not isinstance(width, str):
+            width = 'width={}\\textwidth'.format(width)
+
+        file_name = os.path.basename(children)
+        relpath = os.path.join('inp', file_name)
+        path = './inp/' + file_name
+
+        if imageblob:
+            if isinstance(imageblob, str):
+                if ';base64, ' in imageblob:
+                    imageblob = imageblob.replace(';base64, ', ';base64,')
+
+                imageblob = imageblob.encode("utf8")
+
+            data = imageblob.split(b";base64,")[1]
+            assert not os.path.exists(relpath), f'can not write a file if it already exists! "{children}'
+            
+            self.attachments[relpath] = base64.decodebytes(data)
+
+        txt = fr'\includegraphics[{width}]{{{path}}}'
+
+        if caption:
+            txt += '\n' + fr'\caption{{{caption}}}'
+
+        txt = r"\begin{figure}[h!]" + '\n' + r"\centering" '\n' + txt + '\n' + r"\end{figure}"
+        return txt
+
+
+
+    def digest_verbatim(self, children='', **kwargs) -> str:
+        txt = self.digest(children)
+        template = r"""\begin{tabular}{|p{16cm}|}
+\hline
+\begin{tiny}\begin{verbatim}
+<REPLACEME:VERBTEXT>
+\end{verbatim}\end{tiny}
+\\
+\hline
+\end{tabular}\par"""
+        txt = txt.strip('\n')
+        parts = []
+
+        while len(txt) > 2000:
+            parts.append(template.replace('<REPLACEME:VERBTEXT>', txt[:2000]))
+            txt = txt[2000:]
+        parts.append(template.replace('<REPLACEME:VERBTEXT>', txt))
+
+        txt = '\n\n'.join(parts)
+        # if caption:
+        #     caption = fr'\caption{{{caption}}}'
+
+        # txt = txt.replace('<REPLACEME:CAPTION>', caption)
+
+        return txt
+
+
+    def digest_iterator(self, el) -> str:
+        if isinstance(el, dict) and el.get('typ', '') == 'iter' and isinstance(el.get('children', None), list):
+            el = el['children']
+        return '\n\n'.join([f'% Iterator Element {i}\n' + self.digest(e) for i, e in enumerate(el)])
+    
+    def digest_str(self, el):
+        return el
+        
+    def digest_text(self, children:str, **kwargs):
+        return children
+    
+    def digest(self, el, make_blue=False):
+        blue = lambda s: f'{{\\color{{blue}}{s}}}'
+        try:
+            
+            if not el:
+                return ''
+            elif isinstance(el, str):
+                ret = self.digest_str(el)
+            elif isinstance(el, dict) and 'typ' in el and el['typ'] == 'iter':
+                ret = self.digest_iterator(el)
+            elif isinstance(el, list) and el:
+                ret = self.digest_iterator(el)
+            elif isinstance(el, dict) and 'typ' in el and el['typ'] == 'image':
+                ret = self.digest_image(**el)
+            elif isinstance(el, dict) and 'typ' in el and el['typ'] == 'text':
+                ret = self.digest_text(**el)
+            elif isinstance(el, dict) and 'typ' in el and el['typ'] == 'verbatim':
+                ret = self.digest_verbatim(**el)
+            elif isinstance(el, dict) and 'typ' in el and el['typ'] == 'markdown':
+                ret = self.digest_markdown(**el)
+            else:
+                return self.handle_error(f'the element of typ {type(el)}, could not be parsed.', el)
+            
+            return blue(ret) if make_blue else ret
+        
+        except Exception as err:
+            return self.handle_error(err, el)
+
+
+    def format(self, doc:list) -> str:
+        return '\n\n'.join([self.digest(e, make_blue=self.make_blue) for e in doc])
+
+
+
+
+
+
+
+
+
+
+

pydocmaker-1.0.0/src/pydocmaker.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: pydocmaker
+Version: 1.0.0
+Summary: a minimal document maker to make docx, markdown, html, and tex documents from python. Written in pure python.
+Home-page: https://github.com/TobiasGlaubach/pyandoc
+Author: Tobias Glaubach
+Project-URL: Bug Tracker, https://github.com/TobiasGlaubach/pyandoc/issues
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# pydocmaker
+a minimal document maker to make docx, markdown, html, and tex documents from python.
+Written in pure python. 
+
+Named in honor and spirit after the famous [pandoc](https://github.com/jgm/pandoc) package.

pydocmaker-1.0.0/src/pydocmaker.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+setup.cfg
+setup.py
+src/pydocmaker/__init__.py
+src/pydocmaker.egg-info/PKG-INFO
+src/pydocmaker.egg-info/SOURCES.txt
+src/pydocmaker.egg-info/dependency_links.txt
+src/pydocmaker.egg-info/top_level.txt
+src/pydocmaker/core/__init__.py
+src/pydocmaker/core/schema.py
+src/pydocmaker/exporters/__init__.py
+src/pydocmaker/exporters/ex_docx.py
+src/pydocmaker/exporters/ex_html.py
+src/pydocmaker/exporters/ex_redmine.py
+src/pydocmaker/exporters/ex_tex.py

pydocmaker-1.0.0/src/pydocmaker.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pydocmaker-1.0.0/src/pydocmaker.egg-info/top_level.txt

@@ -0,0 +1 @@
+pydocmaker