regexml 0.1.0__py3-none-any.whl

regexml/__init__.py

@@ -0,0 +1,24 @@
+"""regexml: A lightweight, fault-tolerant, text-first XML extraction library for Python."""
+
+from regexml.models import TagMatch, TagReport, XMLText
+from regexml.extractor import (
+    tagvalue,
+    tagvalues,
+    tagmatch,
+    tagmatches,
+    extract_tags,
+)
+from regexml.inspector import check_tags
+
+__version__ = "0.1.0"
+__all__ = [
+    "XMLText",
+    "TagMatch",
+    "TagReport",
+    "tagvalue",
+    "tagvalues",
+    "tagmatch",
+    "tagmatches",
+    "extract_tags",
+    "check_tags",
+]

regexml/attributes.py

@@ -0,0 +1,60 @@
+"""Resilient attribute parsing for regexml."""
+
+from __future__ import annotations
+import re
+from typing import Dict, Optional
+
+# Resilient attribute regex supporting double quotes, single quotes, unquoted values, and boolean flags
+ATTR_PATTERN = re.compile(
+    r'([a-zA-Z0-9_:-]+)(?:\s*=\s*(?:"([^"]*)"|\'([^\']*)\'|([^\s>]+)))?',
+    re.MULTILINE,
+)
+
+
+def parse_attributes(attr_string: str) -> Dict[str, str]:
+    """
+    Parse XML/HTML attributes from a tag's attribute string into a dictionary.
+    Handles unquoted values, single quotes, double quotes, and boolean attributes.
+    """
+    if not attr_string or not attr_string.strip():
+        return {}
+
+    attributes: Dict[str, str] = {}
+    for match in ATTR_PATTERN.finditer(attr_string):
+        name = match.group(1)
+        if not name:
+            continue
+        
+        # Determine value among the three quote capture groups
+        val_double = match.group(2)
+        val_single = match.group(3)
+        val_unquoted = match.group(4)
+
+        if val_double is not None:
+            value = val_double
+        elif val_single is not None:
+            value = val_single
+        elif val_unquoted is not None:
+            value = val_unquoted
+        else:
+            # Boolean attribute without value (e.g. <input disabled>)
+            value = ""
+
+        attributes[name] = value
+
+    return attributes
+
+
+def matches_attributes(
+    parsed_attrs: Dict[str, str],
+    filter_attrs: Optional[Dict[str, str]],
+) -> bool:
+    """Check if all key-value pairs in filter_attrs match the parsed attributes."""
+    if not filter_attrs:
+        return True
+
+    for k, v in filter_attrs.items():
+        if parsed_attrs.get(k) != v:
+            return False
+
+    return True

regexml/extractor.py

@@ -0,0 +1,121 @@
+"""Core XML extraction engine."""
+
+from __future__ import annotations
+from typing import Any, Dict, List, Optional
+from regexml.models import _MISSING, TagMatch, XMLText
+from regexml.nested import find_balanced_tags
+from regexml.utils import remove_comments, strip_all_tags, unwrap_cdata
+
+
+def tagmatches(
+    text: str,
+    tag: str,
+    ignore_case: bool = False,
+    match_attributes: Optional[Dict[str, str]] = None,
+    allow_unclosed: bool = True,
+    ignore_comments: bool = True,
+    match_namespace: bool = False,
+    **kwargs: Any,
+) -> List[TagMatch]:
+    """
+    Extract all matching occurrences of a tag as TagMatch objects,
+    using balanced depth scanning to accurately capture nested tags.
+    """
+    if text is None:
+        return []
+
+    input_text = str(text)
+    if ignore_comments:
+        input_text = remove_comments(input_text)
+
+    return find_balanced_tags(
+        text=input_text,
+        tag_name=tag,
+        ignore_case=ignore_case,
+        match_attributes=match_attributes,
+        allow_unclosed=allow_unclosed,
+        match_namespace=match_namespace,
+    )
+
+
+def tagmatch(
+    text: str,
+    tag: str,
+    default: Any = None,
+    **kwargs: Any,
+) -> Optional[TagMatch]:
+    """Extract the first matching TagMatch object for a tag."""
+    matches = tagmatches(text, tag, **kwargs)
+    return matches[0] if matches else default
+
+
+def tagvalues(
+    text: str,
+    tag: str,
+    include_tags: bool = False,
+    strip_inner_tags: bool = False,
+    strip_whitespace: bool = True,
+    unwrap_cdata_content: bool = True,
+    **kwargs: Any,
+) -> List[XMLText]:
+    """
+    Extract all matching values for a tag name, returned as a list of XMLText instances.
+    """
+    matches = tagmatches(text, tag, **kwargs)
+    results: List[XMLText] = []
+
+    for m in matches:
+        content = m.raw if include_tags else m.content
+
+        if unwrap_cdata_content:
+            content = unwrap_cdata(content)
+
+        if strip_inner_tags:
+            content = strip_all_tags(content)
+
+        if strip_whitespace:
+            content = content.strip()
+
+        results.append(
+            XMLText(
+                content,
+                is_truncated=m.is_truncated,
+                attributes=m.attributes,
+                tag=m.tag,
+            )
+        )
+
+    return results
+
+
+def tagvalue(
+    text: str,
+    tag: str,
+    default: Any = _MISSING,
+    **kwargs: Any,
+) -> Any:
+    """
+    Extract the value of the first matching tag.
+    Returns XMLText instance or default if not found.
+    """
+    values = tagvalues(text, tag, **kwargs)
+    if values:
+        return values[0]
+    if default is not _MISSING:
+        return default
+    return XMLText("", is_none=True)
+
+
+def extract_tags(
+    text: str,
+    tags: List[str],
+    **kwargs: Any,
+) -> Dict[str, List[XMLText]]:
+    """
+    Batch extract multiple distinct tag names from the input text.
+    Returns a dictionary mapping tag name to list of XMLText values.
+    """
+    output: Dict[str, List[XMLText]] = {}
+    for t in tags:
+        output[t] = tagvalues(text, t, **kwargs)
+    return output

regexml/inspector.py

@@ -0,0 +1,85 @@
+"""Tag inspection, hierarchy discovery, and unclosed tag diagnostics."""
+
+from __future__ import annotations
+import re
+from typing import Any, Dict, List
+from regexml.models import TagReport
+from regexml.utils import remove_comments
+
+TAG_TOKEN_RE = re.compile(
+    r"(?P<closing></(?P<c_tag>[a-zA-Z0-9_.:-]+)\s*>)|"
+    r"(?P<self_closing><(?P<s_tag>[a-zA-Z0-9_.:-]+)(?:\s+[^>]*?)?\s*/>)|"
+    r"(?P<opening><(?P<o_tag>[a-zA-Z0-9_.:-]+)(?:\s+[^>]*?)?>)",
+    re.DOTALL,
+)
+
+
+def check_tags(
+    text: str,
+    ignore_comments: bool = True,
+) -> TagReport:
+    """
+    Inspect all XML tags within the provided text, building a tag hierarchy
+    and identifying any unclosed/truncated tags without validating strict well-formedness.
+    """
+    if text is None:
+        return TagReport(tags=[], tag_counts={}, unclosed_tags=[], hierarchy={}, total_tags=0)
+
+    input_text = str(text)
+    if ignore_comments:
+        input_text = remove_comments(input_text)
+
+    tag_counts: Dict[str, int] = {}
+    stack: List[str] = []
+    
+    # Hierarchy tree root
+    root_hierarchy: Dict[str, Any] = {}
+    node_stack: List[Dict[str, Any]] = [root_hierarchy]
+
+    total_tags = 0
+
+    for match in TAG_TOKEN_RE.finditer(input_text):
+        if match.group("self_closing"):
+            s_tag = match.group("s_tag")
+            total_tags += 1
+            tag_counts[s_tag] = tag_counts.get(s_tag, 0) + 1
+            current_node = node_stack[-1]
+            if s_tag not in current_node:
+                current_node[s_tag] = {}
+
+        elif match.group("opening"):
+            o_tag = match.group("o_tag")
+            total_tags += 1
+            tag_counts[o_tag] = tag_counts.get(o_tag, 0) + 1
+            
+            current_node = node_stack[-1]
+            if o_tag not in current_node:
+                current_node[o_tag] = {}
+            
+            # Push to stack
+            stack.append(o_tag)
+            node_stack.append(current_node[o_tag])
+
+        elif match.group("closing"):
+            c_tag = match.group("c_tag")
+            # If matching opening tag exists on stack
+            if c_tag in stack:
+                # Pop back up to matching tag to handle missing intermediate tags
+                while stack:
+                    popped = stack.pop()
+                    if len(node_stack) > 1:
+                        node_stack.pop()
+                    if popped == c_tag:
+                        break
+
+    # Any tags remaining on the stack at EOF are unclosed/truncated tags
+    unclosed_tags = list(stack)
+    tags_list = list(tag_counts.keys())
+
+    return TagReport(
+        tags=tags_list,
+        tag_counts=tag_counts,
+        unclosed_tags=unclosed_tags,
+        hierarchy=root_hierarchy,
+        total_tags=total_tags,
+    )

regexml/models.py

@@ -0,0 +1,176 @@
+"""Data models and XMLText wrapper class for regexml."""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Union
+
+
+@dataclass
+class TagMatch:
+    """Represents a matched tag with its content, attributes, and location."""
+    tag: str
+    content: str
+    attributes: Dict[str, str] = field(default_factory=dict)
+    raw: str = ""
+    start_pos: int = -1
+    end_pos: int = -1
+    is_truncated: bool = False
+
+    def to_xml_text(self) -> XMLText:
+        """Convert match content to an XMLText instance carrying metadata."""
+        return XMLText(
+            self.content,
+            is_truncated=self.is_truncated,
+            attributes=self.attributes,
+            tag=self.tag,
+        )
+
+
+@dataclass
+class TagReport:
+    """Diagnostic report produced by check_tags()."""
+    tags: List[str]
+    tag_counts: Dict[str, int]
+    unclosed_tags: List[str]
+    hierarchy: Dict[str, Any]
+    total_tags: int = 0
+
+    def tree(self) -> str:
+        """Render a terminal-friendly visual ASCII tree of the tag hierarchy."""
+        lines: List[str] = []
+
+        def _render_node(node: Dict[str, Any], prefix: str = ""):
+            items = list(node.items())
+            for i, (tag_name, children) in enumerate(items):
+                is_last = i == len(items) - 1
+                connector = "└── " if is_last else "├── "
+                unclosed_flag = " (unclosed)" if tag_name in self.unclosed_tags else ""
+                lines.append(f"{prefix}{connector}{tag_name}{unclosed_flag}")
+                new_prefix = prefix + ("    " if is_last else "│   ")
+                if isinstance(children, dict) and children:
+                    _render_node(children, new_prefix)
+
+        if not self.hierarchy:
+            return "(empty or no tags found)"
+
+        _render_node(self.hierarchy)
+        return "\n".join(lines)
+
+
+_MISSING = object()
+
+
+class XMLText(str):
+    """
+    A string subclass that adds resilient XML extraction methods (.tagvalue, .tagvalues, .check_tags).
+    
+    Acts as a drop-in replacement for standard Python strings with 100% compatibility.
+    """
+
+    def __new__(
+        cls,
+        content: str = "",
+        is_truncated: bool = False,
+        is_none: bool = False,
+        attributes: Optional[Dict[str, str]] = None,
+        tag: Optional[str] = None,
+    ):
+        obj = super().__new__(cls, content)
+        obj._is_truncated = is_truncated
+        obj._is_none = is_none
+        obj._attributes = attributes or {}
+        obj._tag = tag
+        return obj
+
+    @property
+    def is_truncated(self) -> bool:
+        """True if the tag content was cut off before its closing tag (e.g., EOF reached)."""
+        return self._is_truncated
+
+    @property
+    def is_none(self) -> bool:
+        """True if this represents an empty/missing tag in a chain."""
+        return self._is_none
+
+    @property
+    def attributes(self) -> Dict[str, str]:
+        """Parsed attributes associated with this tag match."""
+        return self._attributes
+
+    @property
+    def tag(self) -> Optional[str]:
+        """Name of the tag this content was extracted from."""
+        return self._tag
+
+    def __bool__(self) -> bool:
+        """Evaluate falsy if is_none is True or content is empty."""
+        if self._is_none:
+            return False
+        return len(self) > 0
+
+    def tagvalue(
+        self,
+        tag_path: str,
+        default: Any = _MISSING,
+        **kwargs: Any,
+    ) -> Any:
+        """
+        Extract the value of a tag or a nested path of tags (e.g. 'div/name' or 'div.name').
+        Supports method chaining: doc.tagvalue('div').tagvalue('name').
+        """
+        from regexml.extractor import tagvalue as _extract_tagvalue
+
+        # Safe chaining: if this node was already missing in a previous chain call
+        if self._is_none:
+            if default is not _MISSING:
+                return default
+            return XMLText("", is_none=True)
+
+        # Handle path notation: e.g. "div/name/first_name" or "div.name.first_name"
+        if "/" in tag_path:
+            parts = [p.strip() for p in tag_path.split("/") if p.strip()]
+        elif "." in tag_path:
+            parts = [p.strip() for p in tag_path.split(".") if p.strip()]
+        else:
+            parts = [tag_path.strip()]
+
+        current: Any = self
+        for idx, part in enumerate(parts):
+            is_last = idx == len(parts) - 1
+            step_default = default if is_last else _MISSING
+            
+            if hasattr(current, "is_none") and current.is_none:
+                if step_default is not _MISSING:
+                    return step_default
+                return XMLText("", is_none=True)
+
+            current = _extract_tagvalue(str(current), part, default=step_default, **kwargs)
+            if current is None or (isinstance(current, XMLText) and current.is_none):
+                if is_last and default is not _MISSING:
+                    return default
+                current = XMLText("", is_none=True)
+
+        if isinstance(current, XMLText) and current.is_none and default is not _MISSING:
+            return default
+
+        return current
+
+    def tagvalues(
+        self,
+        tag: str,
+        **kwargs: Any,
+    ) -> List[XMLText]:
+        """Extract all occurrences of a tag as a list of XMLText objects."""
+        from regexml.extractor import tagvalues as _extract_tagvalues
+
+        if self._is_none:
+            return []
+        return _extract_tagvalues(str(self), tag, **kwargs)
+
+    def check_tags(self, **kwargs: Any) -> TagReport:
+        """Inspect all tags, nesting, and unclosed/truncated tags."""
+        from regexml.inspector import check_tags as _check_tags
+
+        if self._is_none:
+            return TagReport(tags=[], tag_counts={}, unclosed_tags=[], hierarchy={}, total_tags=0)
+        return _check_tags(str(self), **kwargs)

regexml/nested.py

@@ -0,0 +1,150 @@
+"""Balanced depth-counter scanner for nested XML tags."""
+
+from __future__ import annotations
+import re
+from typing import Dict, List, Optional
+from regexml.models import TagMatch
+from regexml.attributes import parse_attributes, matches_attributes
+
+
+def find_balanced_tags(
+    text: str,
+    tag_name: str,
+    ignore_case: bool = False,
+    match_attributes: Optional[Dict[str, str]] = None,
+    allow_unclosed: bool = True,
+    match_namespace: bool = False,
+) -> List[TagMatch]:
+    """
+    Find balanced matches for a tag name using a depth counter.
+    
+    Ensures that when a tag contains nested child tags of the same name:
+    <div id="outer">
+        <div id="inner">...</div>
+    </div>
+    the entire outer block is captured from the first opening tag to its corresponding
+    balanced closing tag, rather than stopping prematurely at the first closing tag.
+    """
+    flags = re.DOTALL
+    if ignore_case:
+        flags |= re.IGNORECASE
+
+    escaped_tag = re.escape(tag_name)
+    tag_pattern_str = escaped_tag if match_namespace else rf"(?:[a-zA-Z0-9_.-]+:)?{escaped_tag}"
+
+    # Token regex matches:
+    # 1. Opening tag: <tag ...>
+    # 2. Closing tag: </tag>
+    # 3. Self-closing tag: <tag ... />
+    token_re = re.compile(
+        rf"(?P<closing></(?P<c_tag>{tag_pattern_str})\s*>)|"
+        rf"(?P<self_closing><(?P<s_tag>{tag_pattern_str})(?P<s_attrs>(?:\s+[^>]*?)?)\s*/>)|"
+        rf"(?P<opening><(?P<o_tag>{tag_pattern_str})(?P<o_attrs>(?:\s+[^>]*?)?)>)",
+        flags,
+    )
+
+    matches: List[TagMatch] = []
+    text_len = len(text)
+    idx = 0
+
+    while idx < text_len:
+        # Search for the next token from current idx
+        m = token_re.search(text, idx)
+        if not m:
+            break
+
+        # Check token type
+        if m.group("self_closing"):
+            # Self-closing tag: completes immediately
+            tag_name_found = m.group("s_tag")
+            attrs_str = m.group("s_attrs") or ""
+            parsed_attrs = parse_attributes(attrs_str)
+
+            if matches_attributes(parsed_attrs, match_attributes):
+                match_obj = TagMatch(
+                    tag=tag_name_found,
+                    content="",
+                    attributes=parsed_attrs,
+                    raw=m.group(0),
+                    start_pos=m.start(),
+                    end_pos=m.end(),
+                    is_truncated=False,
+                )
+                matches.append(match_obj)
+
+            idx = m.end()
+            continue
+
+        elif m.group("opening"):
+            # Opening tag: start tracking balanced depth
+            tag_name_found = m.group("o_tag")
+            attrs_str = m.group("o_attrs") or ""
+            parsed_attrs = parse_attributes(attrs_str)
+
+            # Check if this opening tag satisfies attribute filter
+            if not matches_attributes(parsed_attrs, match_attributes):
+                idx = m.end()
+                continue
+
+            outer_start = m.start()
+            content_start = m.end()
+            depth = 1
+            inner_idx = content_start
+            found_closing = False
+
+            while inner_idx < text_len:
+                inner_m = token_re.search(text, inner_idx)
+                if not inner_m:
+                    break
+
+                if inner_m.group("self_closing"):
+                    # Self-closing does not alter depth
+                    inner_idx = inner_m.end()
+                elif inner_m.group("opening"):
+                    # Nested opening tag of same name
+                    depth += 1
+                    inner_idx = inner_m.end()
+                elif inner_m.group("closing"):
+                    # Closing tag found
+                    depth -= 1
+                    if depth == 0:
+                        # Balanced closing tag reached!
+                        content = text[content_start:inner_m.start()]
+                        raw = text[outer_start:inner_m.end()]
+                        match_obj = TagMatch(
+                            tag=tag_name_found,
+                            content=content,
+                            attributes=parsed_attrs,
+                            raw=raw,
+                            start_pos=outer_start,
+                            end_pos=inner_m.end(),
+                            is_truncated=False,
+                        )
+                        matches.append(match_obj)
+                        found_closing = True
+                        idx = inner_m.end()
+                        break
+                    else:
+                        inner_idx = inner_m.end()
+
+            if not found_closing:
+                # If closing tag was not found and allow_unclosed is enabled (truncated XML)
+                if allow_unclosed:
+                    content = text[content_start:]
+                    raw = text[outer_start:]
+                    match_obj = TagMatch(
+                        tag=tag_name_found,
+                        content=content,
+                        attributes=parsed_attrs,
+                        raw=raw,
+                        start_pos=outer_start,
+                        end_pos=text_len,
+                        is_truncated=True,
+                    )
+                    matches.append(match_obj)
+                break
+        else:
+            # Standalone closing tag without opening; skip
+            idx = m.end()
+
+    return matches

regexml/utils.py

@@ -0,0 +1,29 @@
+"""String cleanup and regex helper utilities for regexml."""
+
+from __future__ import annotations
+import re
+
+TAG_STRIP_PATTERN = re.compile(r"<[^>]+>", re.DOTALL)
+COMMENT_PATTERN = re.compile(r"<!--.*?-->", re.DOTALL)
+CDATA_PATTERN = re.compile(r"<!\[CDATA\[(.*?)\]\]>", re.DOTALL)
+
+
+def strip_all_tags(text: str) -> str:
+    """Strip all XML/HTML markup tags from text, leaving only the inner content."""
+    if not text:
+        return ""
+    return TAG_STRIP_PATTERN.sub("", text)
+
+
+def remove_comments(text: str) -> str:
+    """Remove XML comments (<!-- ... -->) from text."""
+    if not text:
+        return ""
+    return COMMENT_PATTERN.sub("", text)
+
+
+def unwrap_cdata(text: str) -> str:
+    """Extract contents of CDATA blocks: <![CDATA[ content ]]> -> content."""
+    if not text:
+        return ""
+    return CDATA_PATTERN.sub(r"\1", text)

regexml-0.1.0.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: regexml
+Version: 0.1.0
+Summary: A lightweight, fault-tolerant, text-first XML extraction library for Python.
+Project-URL: Homepage, https://github.com/visitishan/regexml
+Project-URL: Repository, https://github.com/visitishan/regexml
+Project-URL: Issues, https://github.com/visitishan/regexml/issues
+Author-email: Ishan <ishan@example.com>
+License: MIT
+License-File: LICENSE
+Keywords: extractor,fault-tolerant,llm,parser,regex,scraping,xml
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Text Processing :: Markup :: XML
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# regexml 🚀
+
+[![PyPI version](https://img.shields.io/pypi/v/regexml.svg)](https://pypi.org/project/regexml/)
+[![Python Version](https://img.shields.io/badge/python-3.9+-blue.svg)](https://python.org)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+
+A lightweight, fault-tolerant, text-first XML extraction library for Python. Available on PyPI: **[pypi.org/project/regexml](https://pypi.org/project/regexml/)**.
+
+Unlike traditional XML parsers (`xml.etree.ElementTree`, `lxml`) that enforce strict document validation and crash with `ParseError` on incomplete or malformed markup, **`regexml`** treats XML purely as plain text. It extracts values directly using regular expressions and resilient pattern matching.
+
+---
+
+## 🌟 Why `regexml`?
+
+- **Fault-Tolerant & Resilient:** Doesn't crash on unescaped `&`, `<`, `>`, missing closing tags, or broken XML headers.
+- **Perfect for LLM Outputs:** Cleanly extract tags like `<thought>`, `<answer>`, or `<code>` from AI responses.
+- **Fluent Dot-Syntax Chaining:** Call `data.tagvalue("div").tagvalue("name")` seamlessly.
+- **Balanced Outermost Tag Extraction:** Accurately captures outer tags with nested tags of the same name without premature cut-offs.
+- **Truncated Stream Recovery:** If an XML stream cuts off prematurely (e.g. at line 1000 of 1200), it safely captures data up to EOF without failing.
+- **Tag Inspector & Hierarchy:** Built-in `check_tags()` discovers all tags, reports unclosed/truncated tags, and renders visual ASCII trees.
+- **Zero Heavy Dependencies:** Built 100% on Python standard library.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install regexml
+```
+
+---
+
+## ⚡ Quick Start
+
+### 1. Fluent Dot-Syntax (`XMLText`)
+
+Wrap any string with `XMLText` to unlock dot-methods while retaining 100% string compatibility:
+
+```python
+from regexml import XMLText
+
+raw_data = """
+<article id="101">
+    <title>Resilient XML Extraction</title>
+    <author>
+        <first_name>Ishan</first_name>
+        <last_name>Jain</last_name>
+    </author>
+</article>
+"""
+
+doc = XMLText(raw_data)
+
+# Extract single tag value:
+print(doc.tagvalue("title"))
+# Output: Resilient XML Extraction
+
+# Method Chaining:
+print(doc.tagvalue("author").tagvalue("first_name"))
+# Output: Ishan
+
+# Path Shorthand:
+print(doc.tagvalue("author/last_name"))
+# Output: Jain
+```
+
+### 2. Functional API (Without Wrapping)
+
+```python
+from regexml import tagvalue, tagvalues
+
+data = "<user><name>Alice</name><name>Bob</name></user>"
+
+print(tagvalue(data, "name"))        # Alice
+print(tagvalues(data, "name"))       # ['Alice', 'Bob']
+```
+
+---
+
+## 🎯 Advanced Features
+
+### Balanced Nested Tags of the Same Name
+Standard regex chops off at the first closing tag. `regexml` tracks depth counter to return the true balanced outermost tag:
+
+```python
+xml = """
+<div id="outer">
+    Hello
+    <div id="inner">World</div>
+    Welcome!
+</div>
+"""
+doc = XMLText(xml)
+print(doc.tagvalue("div"))
+# Output:
+# Hello
+# <div id="inner">World</div>
+# Welcome!
+```
+
+### Truncated / Broken XML Recovery
+If your XML was cut off mid-stream (e.g., from network drop or LLM token limit):
+
+```python
+truncated_xml = "<user><id>123</id><bio>Software engineer who loves Python... [CUT OFF]"
+doc = XMLText(truncated_xml)
+
+bio = doc.tagvalue("bio")
+print(bio)                  # "Software engineer who loves Python... [CUT OFF]"
+print(bio.is_truncated)     # True
+```
+
+### Tag Inspection & Broken Markup Detection (`check_tags`)
+
+```python
+report = doc.check_tags()
+
+# View all tags found:
+print(report.tags)          # ['user', 'id', 'bio']
+
+# Pinpoint unclosed tags (truncated points):
+print(report.unclosed_tags) # ['user', 'bio']
+
+# Print terminal ASCII tree:
+print(report.tree())
+```
+
+**Output:**
+```text
+└── user (unclosed)
+    ├── id
+    └── bio (unclosed)
+```
+
+The tree instantly visualizes the markup hierarchy and flags unclosed tags, making it easy to pinpoint where the XML stream cut off.
+
+---
+
+## 📄 License
+
+MIT License. Developed by Ishan.

regexml-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+regexml/__init__.py,sha256=2_CkT4CNkX912FGzFUbLwHVdajRgE2tQyQShh4yda2Y,491
+regexml/attributes.py,sha256=yB6xJJi6O5s4oeLn87yEpALH-1VGsvrLS0Du5aaPmls,1737
+regexml/extractor.py,sha256=UqAwpB3WhfXbfLtFE2LqIFk8clFDKTd_v8fh4jyf1dU,3088
+regexml/inspector.py,sha256=mtDWsXM9qvKLtEVJJqIWkU4Zaj5N5YrvL0S9c5I1RbY,2746
+regexml/models.py,sha256=qtGGIJOxX7wdXMq731OmCp1gbRZEPWEaz4g6MCsaCw0,5910
+regexml/nested.py,sha256=dm-nhGCoHLbXEZ4IISHd0N4bySbyd35IS3gkFXZSVhE,5372
+regexml/utils.py,sha256=kb7bl9tJyWscFrxhWwBD4h934kXp5C93Op9orUYcClc,849
+regexml-0.1.0.dist-info/METADATA,sha256=iaT2ucifhxMDyEDCROb4WuTRYJrPKl9c-VyH79gwZ34,5150
+regexml-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+regexml-0.1.0.dist-info/licenses/LICENSE,sha256=aQ9bAE2ZfPPX0z_1Qy1dHN-uKRZZcVRzsM0gFf7JEtM,1062
+regexml-0.1.0.dist-info/RECORD,,

regexml-0.1.0.dist-info/WHEEL

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

regexml-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ishan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.