svgtext 0.0.2__tar.gz

svgtext-0.0.2/.gitignore

@@ -0,0 +1,219 @@
+ide/
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

svgtext-0.0.2/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.5
+Name: svgtext
+Version: 0.0.2
+Summary: Add your description here
+Requires-Python: >=3.12
+Requires-Dist: fonttools>=4.65.0
+Requires-Dist: pandas>=3.0.6
+Requires-Dist: pillow>=12.3.0
+Requires-Dist: pytest-playwright>=0.10.0
+Requires-Dist: tpipe

svgtext-0.0.2/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "svgtext"
+version = "0.0.2"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "fonttools>=4.65.0",
+    "pandas>=3.0.6",
+    "pillow>=12.3.0",
+    "pytest-playwright>=0.10.0",
+    "tpipe",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/svgtext"]
+artifacts = ["src/svgtext/fonts/*"]
+
+[tool.uv.sources]
+tpipe = { url = "https://github.com/ThomasKimber/tpipe/releases/download/v0.001/tpipe-0.1.0-py3-none-any.whl" }

svgtext-0.0.2/src/svgtext/htmltext.py

@@ -0,0 +1,139 @@
+from svgtext.textlayout import word_wrap
+from tpipe import phtml
+import networkx as nx
+from networkx import MultiDiGraph
+
+
+def html_to_markup(source : str, 
+                   word_wrap_limit : int)->list[list[tuple[str,dict[str,dict]]]]:
+    """Process a section of text, breaking it into 
+    separate lines based on a number of 
+    characters defined as a word_wrap_limit and return
+    a proprietary markup consisting of lines of text
+    broken down into individually styled cells.
+    Text can be supplied as straight text, or provided as html
+    """
+    tgraph=html_text_to_graph(source)
+    if len(tgraph)==0:
+        return [[(" ",{})  ]]
+    return [[(text,_get_text_feature_from_graph_hierarchy(tgraph, node)) for text, node in row ] for row in _html_text_word_wrap(source, tgraph, word_wrap_limit) ]
+
+
+
+def _html_section_to_text_layout_grid(html_graph, start_node):
+    """Given an html structural graph (conforming to the definition 
+    in phtml) and a starting node, traverse the graph and extract
+    text nodes, placing them into a grid based on linebreaks and
+    reading sequence. This grid can then be used to further refine
+    layout."""
+    linenumber=-1
+    last_linenumber=0
+    block_sequence=-1
+    subtree=phtml.walk_subtree(html_graph,start_node)
+    node_line_assignments=[]
+    node_line=[]
+    node_rows=[]
+    for n in subtree:
+        node_content = phtml.get_node_data(html_graph, n)
+        node_parent_id = phtml.get_parent_node_id(html_graph, n)
+        if node_content.tag in ('p', 'br'):
+            linenumber=linenumber+1
+        if node_content.text is not None and node_content.node_type=='text':
+            block_sequence=block_sequence+1
+            node_line.append(n)
+        if linenumber != last_linenumber and len(node_line)>0:
+            block_sequence=-1
+            node_rows.append(node_line)
+            node_line=[]
+        node_line_assignments.append((n, (block_sequence, linenumber)))
+        
+        last_linenumber=linenumber
+    if len(node_line)>0:
+        node_rows.append(node_line)
+    return node_rows
+
+def range_mapping(t_range, labelled_range_dict):
+    mappings=[]
+    for k,v in labelled_range_dict.items():
+        if ranges_overlap(range(*t_range), range(*v)):
+            mappings.append(k)
+    return mappings
+
+def ranges_overlap(r1, r2):
+    return max(r1.start, r2.start) < min(r1.stop, r2.stop)
+
+def ranges_intersection(r1, r2):
+    r_intersect = set(r1).intersection(set(r2))
+    return range(min(r_intersect), max(r_intersect))
+
+def range_to_start_end_tuple(r):
+    return r.start, r.stop+1
+
+def html_text_to_graph(source: str) -> nx.MultiDiGraph:
+    return phtml.html_to_graph(source)
+
+def _html_text_word_wrap(source : str, 
+                        tgraph : MultiDiGraph,
+                        word_wrap_length : int):
+    
+    root_el=phtml.root_node_id(tgraph)
+    node_line_assignments = _html_section_to_text_layout_grid(tgraph, root_el)
+    
+    row_node_extents=[]
+    for row in node_line_assignments:
+        node_extents={}
+        row_len=0
+        for node in row:
+            n_text = phtml.get_node_data(tgraph, node).text
+            node_extents[node]=(row_len, row_len+len(n_text))
+            row_len=row_len+len(n_text)
+        row_node_extents.append(node_extents)
+    
+    layout_text = ["".join([phtml.get_node_data(tgraph, t).text for t in row_nodes]) for row_nodes in node_line_assignments]
+    line_wws=[]
+    for line in layout_text:
+        wraps=word_wrap(line, word_wrap_length, " .,\n")
+        line_wws.append(wraps)
+
+    layout=[r for l in [
+            [
+                [
+                    (e, m,range_to_start_end_tuple(ranges_intersection(range(*row_node_extents[e][m]),range(*c))))
+                        for m in (range_mapping(c, row_node_extents[e]))
+                ] 
+                    for c in r
+            ] 
+                for e,r in enumerate(line_wws)
+            ]
+            for r in l]
+    
+    return [[(layout_text[node_span[0]][slice(*node_span[2])], node_span[1]) 
+      for node_span in span] 
+         for span in layout]
+
+
+def _get_text_feature_from_graph_hierarchy(graph, node):
+    features={}
+    ancestors = [a for a in phtml.get_ancestors(graph, node)]
+    tag_name_mapping={
+        "a" : "link",
+        "b" : "bold",
+        "i" : "italic",
+        "sup" : "super",
+        "sub" : "sub"
+    }
+
+    tag__attribute_mapping={
+        "a" : {"href", "title", "target"},
+        "b" : {},
+        "i" : {},
+        "sup" : {},
+        "sub" : {}
+    }
+
+    for a in ancestors:
+        a_node = graph.nodes(data=True)[a]
+        attribute_map = tag__attribute_mapping.get(a_node['data'].tag, None)
+        if attribute_map is not None :
+            features={**features, **{tag_name_mapping.get(a_node['data'].tag) : {v:a_node['data'].attributes.get(v) for v in attribute_map}}}
+    return features

svgtext-0.0.2/src/svgtext/render.py

@@ -0,0 +1,67 @@
+from typing import Hashable
+from playwright.async_api import async_playwright
+import asyncio, base64
+import re
+import base64
+
+def binary_data_to_base64_text(binary_data):
+    """Convert binary data to text data in Base64 format."""
+    return base64.b64encode(binary_data).decode('utf-8').replace('\n', '')
+
+
+def base64_text_to_data_url(base64_text, data_format):
+    """Convert data in form of base64 text to a data URL with suitable prefix."""
+    # Argument processing
+    if data_format == 'jpg':
+        data_format = 'jpeg'
+
+    # Transformation
+    # - MIME type
+    if data_format in ['jpeg', 'png', 'gif', 'webp']:
+        mime_type = 'image/' + data_format
+    elif data_format == 'svg':
+        mime_type = 'image/svg+xml'
+    elif data_format == 'pdf':
+        mime_type = 'application/pdf'
+    elif data_format in ['eps', 'ps']:
+        mime_type = 'application/postscript'
+    else:
+        msg = 'Unknown data format. Can not assign a suitable MIME type.'
+        raise ValueError(msg)
+    # - Data URL
+    data_url = 'data:{};base64,{}'.format(mime_type, base64_text)
+    return data_url
+
+async def batch_svg_to_png(svg_dict : dict)->dict:
+
+    async with async_playwright() as p:
+        browser = await p.chromium.launch()
+        sem = asyncio.Semaphore(8)
+        async def convert(key : Hashable, svg:str)->tuple[Hashable,bytes]:
+            async with sem:
+                png = await svg_to_png(browser, svg)
+                return key, png
+
+        results = await asyncio.gather(*(convert(k,s) for k,s in svg_dict.items()))
+        await browser.close()
+
+    return dict(results)
+        
+
+async def svg_to_png(browser: async_playwright, svg_text: str, scale : int=2) -> bytes:
+    wm = re.search(r'width="([\d.]+)"', svg_text)
+    hm = re.search(r'height="([\d.]+)"', svg_text)
+    w = int(float(wm.group(1)))
+    h = int(float(hm.group(1)))
+
+    page = await browser.new_page(viewport={"width": w, "height": h},
+                                  device_scale_factor=scale)
+    try:
+        await page.set_content(
+            f'<body style="margin:0">{svg_text}</body>',
+            wait_until="load"
+        )
+        await page.evaluate("document.fonts.ready")
+        return await page.locator("svg").screenshot(type="png")
+    finally:
+        await page.close()