lhtml-markup 2.0.0__py3-none-any.whl

lhtml/tag_parser.py

@@ -0,0 +1,214 @@
+"""Lark-based parser for the LHTML :: tag element subsystem.
+
+The grammar is defined in tag_element.lark and handles the syntax
+after :: in constructs like:
+
+    tag::(.class #id)[style]{attrs}text::
+    div::[color:red;]
+    link::url[link text]
+    ::(.class)[style]
+    ::nl
+    ::   (closing tag)
+
+Supports nested brackets: [outer[inner]still_outer]
+"""
+
+import os
+
+from lark import Lark, Transformer, UnexpectedInput
+
+from .errors import LHTMLParseError
+
+
+# ---------------------------------------------------------------------------
+# Load grammar from .lark file
+# ---------------------------------------------------------------------------
+
+_GRAMMAR_PATH = os.path.join(os.path.dirname(__file__), 'tag_element.lark')
+
+with open(_GRAMMAR_PATH) as _f:
+    _GRAMMAR_TEXT = _f.read()
+
+_parser = Lark(_GRAMMAR_TEXT, parser='earley', ambiguity='resolve')
+
+
+# ---------------------------------------------------------------------------
+# Transformer: parse tree -> element dict
+# ---------------------------------------------------------------------------
+
+class _TagElementTransformer(Transformer):
+    """Transforms Lark parse tree into element dict."""
+
+    def _flatten_content(self, items):
+        """Recursively flatten nested bracket content to a string."""
+        parts = []
+        for item in items:
+            if hasattr(item, 'data'):
+                name = item.data
+                inner = self._flatten_content(item.children)
+                if 'paren' in name:
+                    parts.append(f'({inner})')
+                elif 'square' in name:
+                    parts.append(f'[{inner}]')
+                elif 'curly' in name:
+                    parts.append('{' + inner + '}')
+            else:
+                parts.append(str(item))
+        return ''.join(parts)
+
+    def paren_content(self, items):
+        return self._flatten_content(items)
+
+    def square_content(self, items):
+        return self._flatten_content(items)
+
+    def curly_content(self, items):
+        return self._flatten_content(items)
+
+    def paren_group(self, items):
+        return ('()', items[0] if items else '')
+
+    def square_group(self, items):
+        return ('[]', items[0] if items else '')
+
+    def curly_group(self, items):
+        return ('{}', items[0] if items else '')
+
+    def bare_text(self, items):
+        return ('text', str(items[0]))
+
+    def bracket_and_text(self, items):
+        return items[0]
+
+    def start(self, items):
+        return list(items)
+
+
+_transformer = _TagElementTransformer()
+
+
+# ---------------------------------------------------------------------------
+# Forward scanner (bracket-aware)
+# ---------------------------------------------------------------------------
+
+def _scan_forward_bracket_aware(text, start):
+    """Scan forward from start, respecting bracket nesting.
+
+    Stops at space/newline outside brackets, or if text appears after
+    a bracket group that was preceded by text.
+    """
+    idx = start
+    length = len(text)
+    bracket_pairs = {'(': ')', '[': ']', '{': '}'}
+    seen_text = False
+    seen_bracket_after_text = False
+
+    while idx < length:
+        ch = text[idx]
+        if ch == ' ' or ch == '\n':
+            break
+        if ch in bracket_pairs:
+            close = bracket_pairs[ch]
+            depth = 1
+            bracket_start = idx
+            idx += 1
+            while idx < length and depth > 0:
+                if text[idx] == ch:
+                    depth += 1
+                elif text[idx] == close:
+                    depth -= 1
+                idx += 1
+            if depth > 0:
+                raise LHTMLParseError(
+                    f'Unclosed bracket {ch!r} (expected {close!r})',
+                    source_pos=bracket_start,
+                )
+            if seen_text:
+                seen_bracket_after_text = True
+            continue
+        if seen_bracket_after_text:
+            break
+        seen_text = True
+        idx += 1
+
+    return text[start:idx]
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def parse_tag_after_colons(text_after_colons):
+    """Parse the text that appears after :: in an LHTML tag element.
+
+    Returns dict with keys '[]', '()', '{}', 'text'.
+    """
+    result = {'[]': '', '{}': '', '()': '', 'text': ''}
+    if not text_after_colons:
+        return result
+
+    try:
+        tree = _parser.parse(text_after_colons)
+        items = _transformer.transform(tree)
+    except UnexpectedInput:
+        result['text'] = text_after_colons
+        return result
+
+    text_parts = []
+    text_finished = False
+
+    for kind, content in items:
+        if kind == 'text':
+            if not text_finished:
+                text_parts.append(content)
+        else:
+            if text_parts:
+                text_finished = True
+            if result[kind]:
+                result[kind] += ' '
+            result[kind] += content
+
+    result['text'] = ''.join(text_parts)
+    return result
+
+
+def extract_bracket_elements_lark(text, index_start):
+    """Extract bracket elements from an LHTML :: tag expression.
+
+    Args:
+        text: Full document text.
+        index_start: Position right after :: (first char to parse).
+
+    Returns:
+        Dict with keys: '[]', '()', '{}', 'text', 'tag',
+        'index_start', 'index_end'
+    """
+    elements = {
+        '[]': '', '{}': '', '()': '', 'text': '',
+        'tag': '', 'index_start': index_start, 'index_end': index_start,
+    }
+
+    # Backward scan for tag name
+    if index_start >= 2:
+        idx = index_start - 2
+        while idx > 0 and text[idx] != '\n' and text[idx] != ' ' and (text[idx].isalpha() or text[idx] == ':'):
+            idx -= 1
+        if idx == 0 and (text[idx].isalpha() or text[idx] == ':'):
+            tag_start = 0
+        elif text[idx] == '\n' or text[idx] == ' ' or not (text[idx].isalpha() or text[idx] == ':'):
+            tag_start = idx + 1
+        else:
+            tag_start = idx
+        elements['tag'] = text[tag_start:index_start - 2]
+        elements['index_start'] = tag_start
+
+    # Forward scan: bracket-aware extraction
+    if index_start < len(text):
+        after_colons = _scan_forward_bracket_aware(text, index_start)
+        elements['index_end'] = index_start + len(after_colons)
+
+        if after_colons:
+            parsed = parse_tag_after_colons(after_colons)
+            elements.update({k: parsed[k] for k in ('[]', '()', '{}', 'text')})
+
+    return elements

lhtml/wrap_html.py

@@ -0,0 +1,50 @@
+"""HTML document wrapping for LHTML.
+
+Wraps LHTML output in a complete HTML5 document structure
+with head, meta, CSS/JS includes from the YAML metadata.
+"""
+
+HTML_TEMPLATE = """\
+<!DOCTYPE html>
+
+<html lang="en">
+
+<head>
+\t<meta charset="utf-8">
+\t<meta name="viewport" content="width=device-width, initial-scale=1">
+\t<title>{title}</title>
+{head_extras}\
+</head>
+
+<body>
+{content}
+</body>
+
+</html>
+"""
+
+
+def _ensure_list(value):
+    """Normalize a string-or-list meta value to a list."""
+    if isinstance(value, str):
+        return [value]
+    if isinstance(value, list):
+        return value
+    return []
+
+
+def wrap_auto(html_in, meta):
+    """Wrap content in a full HTML5 document using meta configuration."""
+    head_parts = []
+
+    for css in _ensure_list(meta.get('css', [])):
+        head_parts.append(f'\t<link rel="stylesheet" type="text/css" href="{css}">\n')
+
+    for js in _ensure_list(meta.get('js', [])):
+        head_parts.append(f'\t<script src="{js}" defer></script>\n')
+
+    return HTML_TEMPLATE.format(
+        title=meta.get('title', 'Webpage'),
+        head_extras=''.join(head_parts),
+        content=html_in,
+    )

lhtml_markup-2.0.0.dist-info/METADATA

@@ -0,0 +1,402 @@
+Metadata-Version: 2.4
+Name: lhtml-markup
+Version: 2.0.0
+Summary: Lightweight HTML markup language — simplifies HTML authoring with shorthand syntax
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: lark>=1.1
+Requires-Dist: pygments>=2.15
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ansicolors; extra == "dev"
+Dynamic: license-file
+
+# LHTML — Lightweight HTML
+
+LHTML is a markup language that simplifies HTML authoring with embedded CSS styling. It is designed to be **HTML-first**: raw HTML passes through untouched, and only a few shorthand symbols (`::`, `*`, `=`, `**`, `__`) trigger conversions.
+
+LHTML is used to build static websites and presentation slides, typically combined with Jinja2 templates.
+
+## Installation
+
+```bash
+pip install .
+```
+
+Or in development mode:
+
+```bash
+pip install -e .
+```
+
+**Dependencies**: `lark`, `pygments`, `pyyaml` (installed automatically).
+
+
+## Quick Start
+
+### Command Line
+
+```bash
+lhtml input.l.html                    # Convert to stdout
+lhtml input.l.html -o output.html     # Convert to file
+lhtml input.l.html -w                 # Wrap in full HTML document
+python -m lhtml input.l.html          # Alternative invocation
+```
+
+### Python API
+
+```python
+import lhtml
+
+html = lhtml.run('= Hello World\nSome **bold** text.\n')
+
+html = lhtml.run(text, {
+    'wrap-auto': True,
+    'title': 'My Page',
+    'css': ['style.css'],
+    'js': ['script.js'],
+})
+```
+
+
+## Syntax Reference
+
+### Headings
+
+```
+= Main Title
+== Subtitle
+=== Level 3
+```
+
+Output:
+```html
+<h1>Main Title</h1>
+<h2>Subtitle</h2>
+<h3>Level 3</h3>
+```
+
+With classes/IDs:
+```
+=(.highlight #intro) Styled Title
+```
+```html
+<h1 class="highlight" id="intro">Styled Title</h1>
+```
+
+
+### Lists
+
+```
+* First item
+* Second item
+** Nested item A
+** Nested item B
+*** Deep nested
+* Back to top level
+```
+
+Produces nested `<ul><li>` structures.
+
+
+### Inline Formatting
+
+```
+This is **bold** text.
+This is __italic__ text.
+This is `inline code` text.
+```
+
+Output:
+```html
+This is <strong>bold</strong> text.
+This is <em>italic</em> text.
+This is <code class="code-inline">inline code</code> text.
+```
+
+
+### Tag Elements (the `::` system)
+
+The core of LHTML. The general syntax is:
+
+```
+tagName::(.classes #id)[cssStyle]{htmlAttributes} content ::
+```
+
+All bracket groups are optional. If `tagName` is omitted, defaults to `div`.
+
+#### Div / Span with Styles
+
+```
+div::[color:red; font-size:120%;]
+This text is big and red.
+::
+
+span::(.highlight)[font-weight:bold;] inline content ::
+```
+
+Output:
+```html
+<div style="color:red; font-size:120%;">
+This text is big and red.
+</div>
+
+<span class="highlight" style="font-weight:bold;"> inline content </span>
+```
+
+#### Anonymous Div (no tag name)
+
+```
+::[padding:10px; background:#eee;]
+Content in a styled div.
+::
+```
+
+Output:
+```html
+<div style="padding:10px; background:#eee;">
+Content in a styled div.
+</div>
+```
+
+#### Classes, IDs, and Inline Attributes
+
+```
+::(.classA .classB #myId)[margin:10px;]{data-role="main"}
+Content
+::
+```
+
+Output:
+```html
+<div class="classA classB" id="myId" style="margin:10px;" data-role="main">
+Content
+</div>
+```
+
+#### Self-Closing (inline)
+
+End the content with `::` on the same line:
+
+```
+div::[color:blue;] short text ::
+```
+
+Output:
+```html
+<div style="color:blue;"> short text </div>
+```
+
+
+### Links
+
+```
+link::https://example.com[Click here]
+link::page.html(.nav)[Back to home]
+```
+
+Output:
+```html
+<a href="https://example.com">Click here</a>
+<a class="nav" href="page.html">Back to home</a>
+```
+
+
+### Images
+
+```
+img::photo.jpg[width:400px;]
+```
+
+Output:
+```html
+<img style="width:400px;" src="photo.jpg" alt="photo.jpg">
+```
+
+
+### Videos
+
+```
+video::assets/clip.mp4[width:600px;]
+videoplay::assets/clip.mp4[width:600px;]
+```
+
+`videoplay` adds `autoplay loop muted` attributes. The parser automatically detects transcoded codec variants (`-vp9.webm`, `-h265.mp4`, `-h264.mp4`) and poster images (`-poster.jpg`).
+
+
+### Code Blocks
+
+````
+code::[python]
+def hello():
+    print("Hello, world!")
+code::[-]
+````
+
+Syntax highlighting is powered by Pygments. Any language supported by Pygments can be used.
+
+
+### Spacer
+
+```
+::nl
+```
+
+Output:
+```html
+<div style="height:1em;"></div>
+```
+
+
+### Verbatim (raw passthrough)
+
+Content inside verbatim blocks is preserved exactly as-is, with no LHTML processing:
+
+```
+verbatim::[]
+This = is not a title
+**not bold** __not italic__
+div::[not a tag]
+verbatim::[-]
+```
+
+
+### Comments
+
+```
+Some text ::# This comment will be removed
+```
+
+
+### File Inclusion
+
+```
+include::header.html
+include::components/nav.html
+```
+
+Included files are recursively processed (up to 20 levels).
+
+
+### YAML Front Matter
+
+```
+---
+title: "My Page"
+css: ["style.css", "theme.css"]
+js: "app.js"
+wrap-auto: true
+---
+
+= Page content starts here
+```
+
+Supported metadata keys:
+
+| Key | Type | Description |
+|-----|------|-------------|
+| `title` | string | Page title (used in HTML wrapper) |
+| `css` | string or list | CSS files to include |
+| `js` | string or list | JavaScript files to include |
+| `wrap-auto` | boolean | Wrap output in full HTML document |
+| `directory_include` | list | Directories to search for includes |
+
+
+## Plugin System
+
+### Custom Tag Handlers
+
+Register handlers for new `::` tag types:
+
+```python
+from lhtml.pipeline import tag_registry
+
+def handle_alert(element, tag_to_close, current_directory):
+    style = element.get('[]', '')
+    text = element.get('text', '')
+    return f'<div class="alert" style="{style}">{text}</div>', True
+
+tag_registry.register('alert', handle_alert)
+```
+
+Then use in LHTML:
+```
+alert::[background:yellow; padding:10px;] Warning message ::
+```
+
+### Custom Code Lexers
+
+Register custom Pygments lexers for syntax highlighting:
+
+```python
+from lhtml.pipeline import lexer_registry
+from pygments.lexers import PythonLexer
+
+lexer_registry.register('mypython', PythonLexer)
+```
+
+### Custom Pipeline
+
+Create an isolated pipeline with its own tag registry:
+
+```python
+from lhtml.pipeline import ProcessingPipeline, TagRegistry
+
+registry = TagRegistry()
+registry.register('note', my_note_handler)
+
+pipeline = ProcessingPipeline(registry=registry)
+html = pipeline.run(text, {'wrap-auto': True})
+```
+
+
+## Configuration Reference
+
+All keys for the `meta` dict passed to `lhtml.run()`:
+
+```python
+{
+    'wrap-auto': False,        # Wrap in HTML document
+    'title': 'Webpage',        # Document title
+    'css': [],                 # CSS files (string or list)
+    'js': [],                  # JS files (string or list)
+    'directory_include': [],   # Search paths for include::
+    'current_directory': '',   # Base directory for video codec detection
+}
+```
+
+
+## Design Principles
+
+- **HTML-first**: Raw HTML is never modified. Only LHTML syntax triggers conversions.
+- **Island grammar**: LHTML syntax "islands" float in a sea of opaque content (HTML, Jinja2 templates, LaTeX, etc.) that passes through untouched.
+- **Minimal**: A few symbols (`::`, `=`, `*`, `**`, `__`, `` ` ``) cover most needs. No complex configuration required.
+- **Composable**: LHTML works seamlessly with Jinja2 templates, making it suitable for static site generators.
+
+
+## Project Structure
+
+```
+src/lhtml/
+  __init__.py          # Public API: run(), analyse_tag(), read_yaml()
+  cli.py               # Command-line interface
+  pipeline.py          # ProcessingPipeline, TagRegistry, LexerRegistry
+  process.py           # Core transformation functions
+  patterns.py          # Centralized regex patterns and utilities
+  tag_parser.py        # Lark-based parser for :: bracket syntax
+  tag_element.lark     # Lark grammar definition
+  export_html.py       # HTML generation for tag elements
+  listing.py           # List processing
+  code.py              # Code syntax highlighting (Pygments)
+  wrap_html.py         # HTML document wrapping
+  ast_nodes.py         # AST node dataclasses
+  errors.py            # Structured error types
+```
+
+
+## License
+
+MIT

lhtml_markup-2.0.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+lhtml/__init__.py,sha256=u7ANa7U-nJiGJz_d9cXOpQOfreHuZY31ao50xvpDE5I,3064
+lhtml/__main__.py,sha256=1R7j15YAM6-cJ2dF6-xg5ix3npRb1McOx2OYa1IoZbk,86
+lhtml/ast_nodes.py,sha256=gEbiEL5D-V1q_k1YCqpb8Ko4i6hj564-Q2QBHnFtJXw,3384
+lhtml/cli.py,sha256=Gl4TMX_r0AsIFFwRr1uh71L_338cYKAU-cLYl4Ir6-g,1579
+lhtml/code.py,sha256=UIdKHJ9HKlwZp4jpb86auK28GD4QP34KZaPRxOeyLyM,2513
+lhtml/element_extract.py,sha256=rN9NPUOaJOYrWopD241Xdwdg5X0ZvxvrGubTes-dHMc,619
+lhtml/errors.py,sha256=fQ7zwzdwywqeUQY2VWnl0ih-feXRa2pnWj7s--bWpyo,1999
+lhtml/export_html.py,sha256=3fRlAT9mKn0fBCstgjlqYU9uJK302wFtjXFWFxzc6dg,4951
+lhtml/insert_in_text.py,sha256=TSg_oTYh-kyHc6HABerx4C9pzuIfdE1IoZXnm5YcYzo,247
+lhtml/listing.py,sha256=CfX6u4uat4WoBnI0GuvSNj_pLWACGdk87SH1Y3lDGW4,1281
+lhtml/patterns.py,sha256=C9ShYSnZZZrHZ3LGI5EzgpOZnE2XDP0lMLGQPVI56Zs,3322
+lhtml/pipeline.py,sha256=_EcA9xSaumAx0IbMN1Dygl6eA1fuXCgCcRj-CZP1mTc,7337
+lhtml/process.py,sha256=uQ16Bw6rfOhV2ywPLy1ReAlGXvlquVmjxWLFrgkBt0s,8293
+lhtml/tag_element.lark,sha256=z6z77vnHzY7Ywo4hm5zrYyS4MiArA9QulDrlIpAPuVY,870
+lhtml/tag_parser.py,sha256=Wz_DGcRD0E8DuoO2nxFp6Xm-rM70NMn5nmMjFgKC6rk,6529
+lhtml/wrap_html.py,sha256=0V9Zr1SvFKUdp1PbrDZ1BtlUcBVjtRtHFujsKwhh8po,1143
+lhtml_markup-2.0.0.dist-info/licenses/LICENSE.md,sha256=vtub9GYnfalS9yrZ2HblcyHqspQ3GS_J4od_zcT1mAE,1103
+lhtml_markup-2.0.0.dist-info/METADATA,sha256=-lmq7oVvSBJpPO9Y4i5OWdtHlEFGoEbpJd7aw_OegiQ,8007
+lhtml_markup-2.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+lhtml_markup-2.0.0.dist-info/entry_points.txt,sha256=Go5qk4IiwAhHwFlaQqH_rJ_wOR8mG97BAt0LeemuK7M,37
+lhtml_markup-2.0.0.dist-info/top_level.txt,sha256=qx9Rgy0hxw3DSS-CtSK-0faRdTHw3fKbw44QD4qRS7s,6
+lhtml_markup-2.0.0.dist-info/RECORD,,

lhtml_markup-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lhtml_markup-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lhtml = lhtml:main