markdowndata 0.0.1__tar.gz

markdowndata-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 BYU-CS-Course-Ops
+
+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.

markdowndata-0.0.1/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.1
+Name: markdowndata
+Version: 0.0.1
+Summary: Tool to convert markdown tables into json objects
+License: MIT
+Author: Gordon Bean
+Author-email: gbean@cs.byu.edu
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: bs4 (>=0.0.2,<0.0.3)
+Requires-Dist: markdown-it-py (>=3.0.0,<4.0.0)
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)

markdowndata-0.0.1/markdowndata/__init__.py

@@ -0,0 +1,6 @@
+from .process_markdown import MarkDataParser
+
+def load(file):
+    parser = MarkDataParser()
+    parser.load(file.name)
+    return parser.data

markdowndata-0.0.1/markdowndata/content_parser.py

@@ -0,0 +1,114 @@
+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

markdowndata-0.0.1/markdowndata/process_markdown.py

@@ -0,0 +1,59 @@
+from typing import Union, List, IO
+from .section_tree import split_sections, build_section_tree
+from .utils import Node
+
+
+class MarkDataParser:
+    """
+    Parses a Markdown document into a JSON-like dictionary structure.
+    Builds a hierarchy of sections and converts each section's content into a structured form.
+    """
+    def __init__(self):
+        self.data = {}
+
+    def load(self, file: Union[str, IO]) -> dict:
+        """
+        Loads markdown content from a file path or file-like object, parses it,
+        and builds a nested dictionary of structured data.
+        """
+        if isinstance(file, str):
+            with open(file, 'r') as f:
+                text = f.read()
+        else:
+            text = file.read()
+
+        # Split the text into Section objects based on markdown headers
+        sections = split_sections(text)
+
+        # Build a hierarchical tree of sections and subsections
+        section_tree = build_section_tree(sections)
+
+        # Convert the section tree into a JSON-like dictionary structure
+        self.data = self.build_dict(section_tree)
+        return self.data
+
+    def build_dict(self, sections: List[Node]) -> dict:
+        """
+        Recursively converts a list of Node objects into a JSON-like dictionary structure.
+        """
+        result = {}
+        for node in sections:
+            sub_dict = self.build_dict(node.subsections)
+
+            if isinstance(node.parsed, dict):
+                # If the parsed content is a dictionary, merge it with its subsections
+                merged = {**node.parsed, **sub_dict}
+            elif node.subsections:
+                # If subsections exist but parsed content is not a dict,
+                # wrap both into a new dictionary
+                merged = {
+                    'content': node.parsed,
+                    **sub_dict
+                } if node.parsed else sub_dict
+            else:
+                # If no subsections, return the parsed content (could be string, list, or None)
+                merged = node.parsed
+
+            # Use the node's title as the key in the dictionary
+            result[node.title] = merged
+        return result

markdowndata-0.0.1/markdowndata/section_tree.py

@@ -0,0 +1,58 @@
+import re
+from .utils import Section, Node
+from .content_parser import parse_content_block
+
+
+def split_sections(text: str):
+    """
+    Splits the Markdown text into Section objects.
+    Each section is identified by a header (e.g., #, ##, ###).
+    """
+    pattern = re.compile(r'^(?P<header>#+) (?P<title>[^\n]+)', re.MULTILINE)
+    matches = list(pattern.finditer(text))
+
+    sections = []
+    for i, match in enumerate(matches):
+        # Calculate the 'end' of the current section:
+        # It's the start of the next header or the end of the document.
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+
+        sections.append(Section(
+            title=match.group('title').strip(),    # The section's title text
+            level=len(match.group('header')),      # The number of # symbols indicates nesting level
+            start=match.start(),                   # Position where this header starts in the text
+            end=end,                               # Position where this section's content ends
+            content=text[match.end():end].strip()  # The actual text content of this section (excluding header)
+        ))
+
+    return sections
+
+
+def build_section_tree(sections):
+    """
+    Builds a hierarchical tree of Nodes from the list of Section objects.
+    Uses a stack to track the current section hierarchy.
+    """
+    root = Node(title='Root', level=0, parsed={}, subsections=[])
+    stack = [root]
+
+    for section in sections:
+        node = Node(
+            title=section.title,
+            level=section.level,
+            parsed=parse_content_block(section.content),
+            subsections=[]
+        )
+
+        # Find the correct parent in the hierarchy
+        while stack and stack[-1].level >= section.level:
+            stack.pop()
+
+        # Add this node as a child of the current parent
+        parent_node = stack[-1]
+        parent_node.subsections.append(node)
+
+        # Push this node to the stack (might have its own children)
+        stack.append(node)
+
+    return root.subsections

markdowndata-0.0.1/markdowndata/utils.py

@@ -0,0 +1,53 @@
+from typing import Union
+from dataclasses import dataclass
+
+from bs4 import BeautifulSoup
+from markdown_it import MarkdownIt
+
+
+@dataclass
+class Section:
+    """
+    Represents a single section of the Markdown document.
+    Contains its title, header level, location in the original text, and raw content.
+    """
+    title: str
+    level: int
+    start: int
+    end: int
+    content: str
+
+
+@dataclass
+class Node:
+    """
+    Represents a node in the hierarchical section tree.
+    Holds the section title, header level, parsed content, and nested subsections.
+    """
+    title: str
+    level: int
+    parsed: Union[dict, list, str]
+    subsections: list
+
+
+def get_md_soup(text: str) -> BeautifulSoup:
+    """
+    Converts a Markdown text block into HTML and parses it into a BeautifulSoup object.
+    """
+    md_parser = MarkdownIt()
+    md_parser.enable("table")  # Enables markdown table parsing
+    md_parser.enable("code")   # Enables markdown code parsing
+    html = md_parser.render(text)
+    return BeautifulSoup(html, 'html.parser')
+
+
+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
+    except (ValueError, AttributeError):
+        return value

markdowndata-0.0.1/pyproject.toml

@@ -0,0 +1,20 @@
+[tool.poetry]
+name = "markdowndata"
+version = "0.0.1"
+description = "Tool to convert markdown tables into json objects"
+authors = ["Gordon Bean <gbean@cs.byu.edu>", "Robert Greathouse <robbykap@byu.edu>"]
+license = "MIT"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+pyyaml = "^6.0.2"
+bs4 = "^0.0.2"
+markdown-it-py = "^3.0.0"
+
+[tool.poetry.group.dev.dependencies]
+python-dotenv = "^1.0.1"
+pytest = "^8.2.2"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"