markdowndata 0.0.1__tar.gz → 0.0.3__tar.gz

{markdowndata-0.0.1 → markdowndata-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: markdowndata
-Version: 0.0.1
+Version: 0.0.3
 Summary: Tool to convert markdown tables into json objects
 License: MIT
 Author: Gordon Bean

markdowndata-0.0.3/markdowndata/content_parser.py

@@ -0,0 +1,180 @@
+import re
+import yaml
+
+from .utils import convert_value, get_md_soup, is_single_tag_block, is_structural_line
+
+
+def detect_value_type(text: str) -> str | None:
+    """
+    Detect the type of content block (YAML, table, list, or text).
+    Only classifies as md_table or md_list if the content is *only* that structure.
+    """
+    text = text.strip()
+    if not text:
+        return None
+
+    # YAML detection (delimited by ===)
+    if re.search(r'===\s*\n(.*?)\n===', text, re.DOTALL):
+        return 'yaml_dict'
+
+    # Convert markdown to HTML
+    soup = get_md_soup(text)
+
+    # Check for exactly one <table> and no other tags or text
+    if soup.find('table') and is_single_tag_block(soup, 'table'):
+        return 'md_table'
+
+    # Check for exactly one <ul> and no other tags or text
+    if soup.find('ul') and is_single_tag_block(soup, 'ul'):
+        return 'md_list'
+
+    # Fallback: process everything as Markdown text
+    return 'md_text'
+
+
+def yaml_dict_parser(text: str) -> dict:
+    """
+    Parse YAML from a string (surrounded by ===) and returns it as a dictionary.
+    Assumes YAML is a block at the beginning of the text.
+    """
+    match = re.search(r'===\s*\n(.*?)\n===', text, re.DOTALL)
+    if match:
+        yaml_data = yaml.safe_load(match.group(1))
+        if yaml_data:
+            return {k: convert_value(v) for k, v in yaml_data.items()}
+    return {}
+
+
+def md_table_parser(text: str) -> list[dict]:
+    """
+    Parse a Markdown table and returns it as a list of dictionaries.
+    Assumes the markdown is converted to HTML with <table> elements.
+    """
+    soup = get_md_soup(text)
+    table = soup.find('table')
+    if not table:
+        return []
+
+    # Extract headers and row data
+    headers = [th.get_text(strip=True) for th in table.find_all('th')]
+    rows = []
+    for tr in table.find_all('tr')[1:]:  # Skip header row
+        cells = [convert_value(td.get_text(strip=True)) for td in tr.find_all(['td', 'th'])]
+        if len(cells) == len(headers):
+            rows.append(dict(zip(headers, cells)))
+
+    return rows
+
+
+def md_list_parser(text: str) -> list:
+    """
+    Parse a Markdown list and returns it as a list of values.
+    Assumes the markdown is converted to HTML with <ul> elements.
+    """
+    soup = get_md_soup(text)
+    ul = soup.find('ul')
+    if not ul:
+        return []
+    return [convert_value(li.get_text(strip=True)) for li in ul.find_all('li')]
+
+
+def md_text_parser(text: str) -> str:
+    """
+    Parse Markdown text by:
+    - Joining lines separated by a single newline (soft breaks)
+    - Preserving formatting (bold, italic, headers, code, code block, etc.)
+    - Preserving paragraph breaks (double or more newlines)
+    - Preserving fenced code blocks exactly
+    """
+    process_text = process_code_blocks(text, process_soft_breaks)
+    return convert_value(process_text)
+
+
+def process_code_blocks(text: str, non_code_callback) -> str:
+    """
+    Process Markdown text, preserving fenced code blocks and applying a transformation
+    only to the non-code sections using `non_code_callback`.
+    """
+    code_pattern = re.compile(r'```.*?```', re.DOTALL)
+    result = []
+    last_end = 0
+
+    for match in code_pattern.finditer(text):
+        start, end = match.span()
+        non_code_part = text[last_end:start]
+        code_block = match.group()
+
+        if non_code_part.strip():
+            result.append(non_code_callback(non_code_part))
+        result.append(code_block)
+
+        last_end = end
+
+    remaining = text[last_end:]
+    if remaining.strip():
+        result.append(non_code_callback(remaining))
+
+    return '\n\n'.join(result)
+
+
+def process_soft_breaks(text: str) -> str:
+    """
+    Joins lines separated by a single newline, except for Markdown block elements:
+    - Lists
+    - Tables
+    - Blockquotes
+    Preserves paragraph breaks (2+ newlines).
+    """
+    lines = text.split('\n')
+    processed = []
+    paragraph_lines = []
+
+    for line in lines:
+        if line.strip() == '':
+            if paragraph_lines:
+                processed.append(' '.join(paragraph_lines))
+                paragraph_lines = []
+            processed.append('')
+            continue
+
+        if is_structural_line(line):
+            if paragraph_lines:
+                processed.append(' '.join(paragraph_lines))
+                paragraph_lines = []
+            processed.append(line)
+        else:
+            paragraph_lines.append(line.strip())
+
+    if paragraph_lines:
+        processed.append(' '.join(paragraph_lines))
+
+    return '\n'.join(processed)
+
+
+def parse_content_block(text: str):
+    """
+    Parse a given block of Markdown text into structured data.
+    Automatically detects the content type (YAML, table, list, text) and
+    dispatches to the appropriate parser. Raises an error if the content
+    cannot be parsed or returns an empty result.
+    """
+    text = text.strip()
+    if not text:
+        return {}
+
+    v_type = detect_value_type(text)
+    if not v_type:
+        raise ValueError(f'No parser found for content: {text}')
+
+    parser_functions = {
+        'yaml_dict': yaml_dict_parser,
+        'md_table': md_table_parser,
+        'md_list': md_list_parser,
+        'md_text': md_text_parser
+    }
+
+    parser = parser_functions[v_type]
+    value = parser(text)
+    if not value:
+        raise ValueError(f'Parser for {v_type} returned empty value for: {text}')
+    return value

{markdowndata-0.0.1 → markdowndata-0.0.3}/markdowndata/utils.py

@@ -1,3 +1,4 @@
+import re
 from typing import Union
 from dataclasses import dataclass
 
@@ -5,6 +6,9 @@ from bs4 import BeautifulSoup
 from markdown_it import MarkdownIt
 
 
+STRUCTURAL_LINE_RE = re.compile(r'^(\s*[-*+]\s+|\s*\d+\.\s+|\|.+\||>\s*)')
+
+
 @dataclass
 class Section:
     """
@@ -41,13 +45,33 @@ def get_md_soup(text: str) -> BeautifulSoup:
     return BeautifulSoup(html, 'html.parser')
 
 
+def is_single_tag_block(soup, tag_name: str) -> bool:
+    """
+    Check if the block consists of a single top-level tag (e.g. <table>, <ul>)
+    with no other sibling tags.
+    """
+    tags = soup.find_all(recursive=False)
+    return len(tags) == 1 and tags[0].name == tag_name
+
+
+def is_structural_line(line: str) -> bool:
+    """
+    Returns True if the line is a Markdown block element (list, table row, blockquote).
+    """
+    return bool(STRUCTURAL_LINE_RE.match(line))
+
+
 def convert_value(value: str) -> Union[int, float, str]:
     """
     Convert a string to an int, float, or datetime object is possible, or return the original string.
     """
     try:
         value = value.strip()
-        num = float(value)
-        return int(num) if num.is_integer() else num
+        if value.isdigit():
+            return int(value)
+        elif '.' in value:
+            return float(value)
+        else:
+            return value
     except (ValueError, AttributeError):
         return value

{markdowndata-0.0.1 → markdowndata-0.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "markdowndata"
-version = "0.0.1"
+version = "0.0.3"
 description = "Tool to convert markdown tables into json objects"
 authors = ["Gordon Bean <gbean@cs.byu.edu>", "Robert Greathouse <robbykap@byu.edu>"]
 license = "MIT"

markdowndata-0.0.1/markdowndata/content_parser.py

@@ -1,114 +0,0 @@
-import re
-import yaml
-
-from .utils import convert_value, get_md_soup
-
-
-def detect_value_type(text: str) -> str | None:
-    """
-    Detect the type of content block (YAML, table, list, or text).
-    Returns the content type string or None if no match is found.
-    """
-    text = text.strip()
-    if not text:
-        return None
-
-    # YAML detection (delimited by ---)
-    if re.search(r'---\s*\n(.*?)\n---', text, re.DOTALL):
-        return 'yaml_dict'
-
-    # Convert markdown to HTML and analyze for tables, lists, or text
-    soup = get_md_soup(text)
-    if soup.find('table'):
-        return 'md_table'
-    elif soup.find('ul'):
-        return 'md_list'
-    elif soup.get_text(strip=True):
-        return 'md_text'
-
-    return None
-
-
-def yaml_dict_parser(text: str) -> dict:
-    """
-    Parse YAML from a string (surrounded by ---) and returns it as a dictionary.
-    Assumes YAML is a block at the beginning of the text.
-    """
-    match = re.search(r'---\s*\n(.*?)\n---', text, re.DOTALL)
-    if match:
-        yaml_data = yaml.safe_load(match.group(1))
-        if yaml_data:
-            return {k: convert_value(v) for k, v in yaml_data.items()}
-    return {}
-
-
-def md_table_parser(text: str) -> list[dict]:
-    """
-    Parse a Markdown table and returns it as a list of dictionaries.
-    Assumes the markdown is converted to HTML with <table> elements.
-    """
-    soup = get_md_soup(text)
-    table = soup.find('table')
-    if not table:
-        return []
-
-    # Extract headers and row data
-    headers = [th.get_text(strip=True) for th in table.find_all('th')]
-    rows = []
-    for tr in table.find_all('tr')[1:]:  # Skip header row
-        cells = [convert_value(td.get_text(strip=True)) for td in tr.find_all(['td', 'th'])]
-        if len(cells) == len(headers):
-            rows.append(dict(zip(headers, cells)))
-
-    return rows
-
-
-def md_list_parser(text: str) -> list:
-    """
-    Parse a Markdown list and returns it as a list of values.
-    Assumes the markdown is converted to HTML with <ul> elements.
-    """
-    soup = get_md_soup(text)
-    ul = soup.find('ul')
-    if not ul:
-        return []
-    return [convert_value(li.get_text(strip=True)) for li in ul.find_all('li')]
-
-
-def md_text_parser(text: str) -> str:
-    """
-    Parse a Markdown text block and return its text content as a string.
-    Ensures lines flow together as a paragraph, not split across lines.
-    """
-    soup = get_md_soup(text)
-    raw_text = soup.get_text(strip=True)
-    return convert_value(' '.join(raw_text.splitlines()))
-
-
-def parse_content_block(text: str):
-    """
-    Parse a given block of Markdown text into structured data.
-    Automatically detects the content type (YAML, table, list, text) and
-    dispatches to the appropriate parser. Raises an error if the content
-    cannot be parsed or returns an empty result.
-    """
-    text = text.strip()
-    if not text:
-        return {}
-
-    v_type = detect_value_type(text)
-    if not v_type:
-        raise ValueError(f'No parser found for content: {text}')
-
-    parser_functions = {
-        'yaml_dict': yaml_dict_parser,
-        'md_table': md_table_parser,
-        'md_list': md_list_parser,
-        'md_text': md_text_parser
-    }
-
-    parser = parser_functions[v_type]
-    value = parser(text)
-    if not value:
-        raise ValueError(f'Parser for {v_type} returned empty value for: {text}')
-    return value