pyact-cli 0.3.0__tar.gz → 0.5.0__tar.gz

{pyact_cli-0.3.0 → pyact_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyact-cli
-Version: 0.3.0
+Version: 0.5.0
 Summary: A CLI tool to compile .pamd files to Markdown.
 Home-page: https://github.com/Abstergo2003/PyAct
 Author: Abstergo2003
@@ -65,10 +65,17 @@ You can also include other pamd files as templates!
 <tmp>path/to/another_file</tmp>
 ```
 
-### 3. Compile!
+### 3. Compile to Markdown
 Run the compiler from your terminal to generate your final Markdown document:
 ```bash
 pyact path/to/your_file.pamd -o output.md
 ```
 
-That's it! You now have a standard Markdown file ready to be shared, published, or converted to PDF.
+### 4. Compile to Word (DOCX)
+You can also compile straight to a native Microsoft Word Document, complete with CSS styling! 
+```bash
+pyact path/to/your_file.pamd -o output.md --docx output.docx
+```
+*Note: If you have a `style.css` file in the same directory, PyAct will automatically load it to style your Word Document. You can also specify one manually using the `--css path/to/style.css` flag!*
+
+That's it! You now have documents ready to be shared, published, or distributed.

{pyact_cli-0.3.0 → pyact_cli-0.5.0}/README.md

@@ -45,10 +45,17 @@ You can also include other pamd files as templates!
 <tmp>path/to/another_file</tmp>
 ```
 
-### 3. Compile!
+### 3. Compile to Markdown
 Run the compiler from your terminal to generate your final Markdown document:
 ```bash
 pyact path/to/your_file.pamd -o output.md
 ```
 
-That's it! You now have a standard Markdown file ready to be shared, published, or converted to PDF.
+### 4. Compile to Word (DOCX)
+You can also compile straight to a native Microsoft Word Document, complete with CSS styling! 
+```bash
+pyact path/to/your_file.pamd -o output.md --docx output.docx
+```
+*Note: If you have a `style.css` file in the same directory, PyAct will automatically load it to style your Word Document. You can also specify one manually using the `--css path/to/style.css` flag!*
+
+That's it! You now have documents ready to be shared, published, or distributed.

pyact_cli-0.5.0/pamd_helpers/__init__.py

@@ -0,0 +1,185 @@
+import inspect
+from typing import Callable, List, Any
+from pyact.py2tex import py2tex
+
+def equation(func: Callable, values: List[Any]) -> str:
+    """
+    Converts a Python lambda or simple function into a LaTeX math equation string.
+    
+    Why it is needed:
+    To allow users to define equations in Python syntax and automatically render them 
+    as mathematical formulas in the final document, without needing to hand-write LaTeX.
+    
+    Inputs:
+        func (Callable): A simple Python function (e.g., `lambda x: x**2`).
+        values (List[Any]): The arguments to pass to the function to compute the result.
+        
+    Outputs:
+        str: A Markdown math string formatted as `$$ Name = Equation = Value $$`.
+    """
+    source = inspect.getsource(func)
+    value = func(*values)
+    name, sep, tail = source.rpartition("=")
+    head, sep, equ = tail.rpartition(":")
+    return f"$$ {name} = {py2tex(equ.replace(chr(10), ''))} = {value} $$"
+
+def image(link: str, caption: str) -> str:
+    """
+    Generates a Markdown image string with an embedded HTML caption.
+    
+    Why it is needed:
+    Standard Markdown images `![caption](url)` don't display visible captions below the image.
+    This helper injects a styled HTML `<span>` below the image to force a visual caption.
+    
+    Inputs:
+        link (str): The URL or local path to the image.
+        caption (str): The text to display as the caption.
+        
+    Outputs:
+        str: A formatted string containing the Markdown image and HTML span caption.
+    """
+    image_link = f"![{caption}]({link})"
+    caption_html = f"<span style='text-align: center; display: block; font-style: italic;'>{caption}</span>"
+    return f"{image_link} \n {caption_html}"
+
+def table(headers: List[str], values: List[List[Any]], caption: str, add_no: bool = False, starting_number: int = 1) -> str:
+    """
+    Generates a Markdown table from Python lists, including a caption.
+    
+    Why it is needed:
+    Writing Markdown tables by hand is tedious. This function allows users to programmatically 
+    build tables from 2D data arrays, inject automatic numbering, and append a styled caption.
+    
+    Inputs:
+        headers (List[str]): List of column header names.
+        values (List[List[Any]]): A 2D list containing the row data.
+        caption (str): The text to display above the table.
+        add_no (bool): If True, adds an auto-incrementing "No." column to the left.
+        starting_number (int): The starting index for the "No." column.
+        
+    Outputs:
+        str: A formatted Markdown string containing the caption and the table.
+    """
+    if add_no:
+        headers_string = f"|No.|"
+        breaker_line = "|---|"
+    else:
+        headers_string = f"|"
+        breaker_line = "|"
+
+    for i in headers:
+        headers_string += f"{i}|"
+        breaker_line += "-"*len(i)+"|"
+
+    table_content = ""
+    for i, row in enumerate(values):
+        if add_no:
+            table_content += f"|{i+starting_number}|"
+        else:
+            table_content += "|"
+        for value in row:
+            table_content += f"{value}|"
+        table_content += "\n"
+
+    caption_html = f"<span style='text-align: center; display: block; font-style: italic;'>{caption}</span>"
+    return f"{caption_html} \n {headers_string}\n{breaker_line}\n{table_content}"
+
+def hyperlink(caption: str, link: str) -> str:
+    """
+    Generates a simple Markdown hyperlink.
+    
+    Why it is needed:
+    Provides a standardized helper method in the PyAct ecosystem for injecting links.
+    
+    Inputs:
+        caption (str): The clickable text to display.
+        link (str): The URL destination.
+        
+    Outputs:
+        str: The Markdown hyperlink string `[caption](link)`.
+    """
+    return f"[{caption}]({link})"
+
+def unordered_list(items: List[str]) -> str:
+    """
+    Generates a Markdown unordered (bullet) list from a Python list.
+    
+    Why it is needed:
+    Allows programmatic generation of bullet points from array data.
+    
+    Inputs:
+        items (List[str]): A list of string items.
+        
+    Outputs:
+        str: A Markdown string where each item is prefixed with `* `.
+    """
+    list_string = ""
+    for i in items:
+        list_string += f"* {i}\n"
+    return list_string
+
+def ordered_list(items: List[str]) -> str:
+    """
+    Generates a Markdown ordered (numbered) list from a Python list.
+    
+    Why it is needed:
+    Allows programmatic generation of numbered lists from array data.
+    
+    Inputs:
+        items (List[str]): A list of string items.
+        
+    Outputs:
+        str: A Markdown string where each item is numbered sequentially (1. 2. 3.).
+    """
+    list_string = ""
+    for i, item in enumerate(items):
+        list_string += f"{i+1}. {item}\n"
+    return list_string
+
+def checklist(items: List[str]) -> str:
+    """
+    Generates a Markdown task checklist from a Python list.
+    
+    Why it is needed:
+    Allows programmatic generation of checkable task items.
+    
+    Inputs:
+        items (List[str]): A list of string items.
+        
+    Outputs:
+        str: A Markdown string where each item is prefixed with `- [ ] `.
+    """
+    list_string = ""
+    for i in items:
+        list_string += f"- [ ] {i}\n"
+    return list_string
+
+class Footnote:
+    """
+    A helper class for managing Markdown footnotes.
+    
+    Why it is needed:
+    Footnotes require two separate parts in Markdown: the annotation mark in the text `[^1]`, 
+    and the definition at the bottom of the document `[^1]: The text`. This class links 
+    the two together to prevent numbering mismatches.
+    """
+    def __init__(self, number: int, text: str):
+        """
+        Inputs:
+            number (int): The footnote reference number.
+            text (str): The expanded text definition of the footnote.
+        """
+        self.number = number
+        self.text = text
+
+    def define_string(self) -> str:
+        """
+        Outputs (str): The full footnote definition block to place at the bottom of the document.
+        """
+        return f"[^{self.number}]: {self.text}"
+
+    def adnotation(self) -> str:
+        """
+        Outputs (str): The short inline reference marker to place in the paragraph text.
+        """
+        return f"[^{self.number}]\n"

pyact_cli-0.5.0/pyact/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.5.0"

pyact_cli-0.5.0/pyact/cli.py

@@ -0,0 +1,75 @@
+import argparse
+import sys
+import os
+from .core import map_content, process_content
+
+def main():
+    """
+    Main entry point for the PyAct Command Line Interface.
+    
+    Why it is needed:
+    This acts as the bridge between the terminal and the PyAct compilation engine. 
+    It parses command-line arguments, triggers the document mapping/compilation process, 
+    and handles file I/O for outputting the compiled Markdown and DOCX files.
+    
+    Inputs (via sys.argv):
+        input (str): Positional argument for the target `.pamd` file path.
+        --output (str): Optional path to save the generated `.md` file.
+        --docx (str): Optional path to save the generated `.docx` file.
+        --css (str): Optional path to a `.css` file for styling the DOCX output.
+        
+    Outputs:
+        Writes the generated `.md` and `.docx` files to the filesystem and prints 
+        status messages to stdout/stderr.
+    """
+    parser = argparse.ArgumentParser(description="PyAct CLI - PAMD to Markdown compiler")
+    parser.add_argument("input", help="Path to the main .pamd file")
+    parser.add_argument("-o", "--output", help="Output file path (default prints to stdout)")
+    parser.add_argument("--docx", help="Also generate a DOCX file at this path")
+    parser.add_argument("--css", help="Optional CSS file path to style the DOCX")
+    
+    args = parser.parse_args()
+    
+    input_path = os.path.abspath(args.input)
+    directory = os.path.dirname(input_path)
+    filename = os.path.basename(input_path)
+    
+    if filename.endswith(".pamd"):
+        filename = filename[:-5]
+        
+    try:
+        build_tree = map_content(filename, directory)
+        content = process_content(build_tree)
+        
+        if args.output:
+            with open(args.output, "w", encoding="utf-8") as f:
+                f.write(content)
+            print(f"Successfully compiled to {args.output}")
+        else:
+            print(content)
+            
+        if args.docx:
+            from .mdTOword import style_parser, markdown_parser, docx_writer
+            styles = {}
+            if args.css:
+                styles = style_parser(args.css)
+            else:
+                # Try to look for style.css in the active directory
+                local_css = os.path.join(directory, "style.css")
+                if os.path.exists(local_css):
+                    styles = style_parser(local_css)
+                else:
+                    # Fallback to the default one packaged in pyact
+                    default_css = os.path.join(os.path.dirname(__file__), "style.css")
+                    styles = style_parser(default_css)
+                    
+            blocks = markdown_parser(content)
+            docx_writer(blocks, styles, args.docx)
+            print(f"Successfully compiled DOCX to {args.docx}")
+            
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

pyact_cli-0.5.0/pyact/core.py

@@ -0,0 +1,198 @@
+import re
+import json
+
+def get_directory(path: str) -> list:
+    """
+    Splits a full file path into its directory component and its filename component.
+    
+    Why it is needed:
+    When resolving nested templates or generating output files, the engine needs to 
+    know the base directory of the current `.pamd` file so it can correctly locate 
+    sibling template files.
+    
+    Inputs:
+        path (str): The full path to a file (e.g., './main/retro.pamd').
+        
+    Outputs:
+        list: A two-element list `[directory_path, filename]`.
+    """
+    head, sep, tail = path.rpartition('/')
+    return [head + sep, tail]
+
+def read_pamd_cells(file_path: str):
+    """
+    Reads a .pamd (JSON Notebook) file and extracts the Markdown and Python code.
+    
+    Why it is needed:
+    `.pamd` files are stored exactly like Jupyter Notebooks (a list of cell objects). 
+    This function parses the JSON structure and concatenates all 'code' cells into a 
+    single executable Python script, and all 'markdown' cells into a single Markdown document.
+    
+    Inputs:
+        file_path (str): Path to the `.pamd` file to read.
+        
+    Outputs:
+        tuple (str, str): A tuple containing `(code_content, markdown_content)`.
+    """
+    with open(file_path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    
+    code_content = ""
+    markdown_content = ""
+    
+    for cell in data.get("cells", []):
+        cell_type = cell.get("cell_type", "")
+        source = cell.get("source", "")
+        if isinstance(source, list):
+            source = "".join(source)
+            
+        if cell_type == "code":
+            code_content += source + "\n"
+        elif cell_type == "markdown":
+            markdown_content += source + "\n"
+            
+    return code_content, markdown_content
+
+def get_imports(file: str, code_text: str):
+    """
+    Executes the Python code from a .pamd file and retrieves the context variables.
+    
+    Why it is needed:
+    To inject dynamic data into the Markdown document, PyAct executes the user's Python 
+    script. The user must define a `context()` function that returns a dictionary mapping 
+    variable names (like 'title') to their computed values. This function safely executes 
+    that code and extracts the resulting dictionary.
+    
+    Inputs:
+        file (str): The name of the file being executed (for error reporting).
+        code_text (str): The raw Python code extracted from the `.pamd` file.
+        
+    Outputs:
+        dict: The dictionary of variables returned by the user's `context()` function.
+    """
+    file_namespace = {"__file__": f"{file}.pamd"}
+    if not code_text.strip():
+        raise ValueError(f"The file {file}.pamd needs a 'context()' function but has no code cell.")
+        
+    try:
+        exec(code_text, file_namespace)
+    except Exception as e:
+        raise RuntimeError(f"Error executing code in {file}.pamd: {e}")
+
+    if "context" not in file_namespace:
+        raise ValueError(f"The file {file}.pamd is missing the required 'context()' function.")
+
+    context_func = file_namespace["context"]
+
+    if not callable(context_func):
+        raise TypeError(f"In {file}.pamd, 'context' was found but it is not a function!")
+
+    result_dict = context_func()
+
+    if not isinstance(result_dict, dict):
+        raise TypeError(f"The 'context()' function in {file}.pamd must return a dictionary.")
+
+    return result_dict
+
+def find_imports(text: str):
+    """
+    Finds all `<ctx>var_name</ctx>` tags in a markdown string.
+    
+    Why it is needed:
+    Identifies which variables the Markdown document is requesting from the Python context.
+    
+    Inputs:
+        text (str): The raw Markdown text.
+        
+    Outputs:
+        list: A list of variable names extracted from the tags.
+    """
+    pattern = r"<ctx>(.*?)</ctx>"
+    return re.findall(pattern, text)
+
+
+def find_templates(text: str):
+    """
+    Finds all `<tmp>file_name</tmp>` tags in a markdown string.
+    
+    Why it is needed:
+    Identifies nested `.pamd` template files that need to be recursively compiled 
+    and injected into the current document.
+    
+    Inputs:
+        text (str): The raw Markdown text.
+        
+    Outputs:
+        list: A list of template file names extracted from the tags.
+    """
+    pattern = r"<tmp>(.*?)</tmp>"
+    return re.findall(pattern, text)
+
+def map_content(file: str, path: str):
+    """
+    Recursively maps the dependency tree of a `.pamd` file.
+    
+    Why it is needed:
+    Before compiling, PyAct needs to build an Abstract Syntax Tree (AST) of the document, 
+    mapping out all required context variables and any nested child templates that need 
+    to be resolved. This allows for deep, nested project structures.
+    
+    Inputs:
+        file (str): The target `.pamd` file name (without extension).
+        path (str): The directory where the file is located.
+        
+    Outputs:
+        dict: A recursive "build tree" dictionary containing metadata, required imports, 
+              and the build trees of all nested templates.
+    """
+    if path and not path.endswith('/'):
+        full_path = f"{path}/{file}"
+    elif path.endswith('/'):
+        full_path = f"{path}{file}"
+    else:
+        full_path = file
+        
+    code_text, main_file = read_pamd_cells(f"{full_path}.pamd")
+    templates = find_templates(main_file)
+    imports = find_imports(main_file)
+    meta = get_directory(full_path)
+    
+    ready_t = []
+    for i in templates:
+        ready_t.append(map_content(i, meta[0]))
+
+    return {
+        "tag_name": file,
+        "name": meta[1],
+        "path": meta[0],
+        "imports": imports,
+        "templates": ready_t
+    }
+
+def process_content(build_tree: dict):
+    """
+    Compiles a mapped build tree into a final flat Markdown string.
+    
+    Why it is needed:
+    This is the core renderer. It reads the `.pamd` files, executes their Python code 
+    to fetch the context dictionary, replaces all `<ctx>` tags with dynamic data, 
+    and recursively replaces all `<tmp>` tags with their fully compiled child documents.
+    
+    Inputs:
+        build_tree (dict): The AST mapping generated by `map_content()`.
+        
+    Outputs:
+        str: The final, fully compiled Markdown text string ready for export.
+    """
+    file_path_base = build_tree.get("path", "") + build_tree.get("name", "")
+    code_text, file_text = read_pamd_cells(file_path_base + ".pamd")
+    
+    needed_imports = build_tree.get("imports", [])
+    if needed_imports:
+        imports = get_imports(file_path_base, code_text)
+        for i in needed_imports:
+            file_text = file_text.replace(f"<ctx>{i}</ctx>", str(imports.get(i, '')))
+
+    for i in build_tree.get("templates", []):
+        file_text = file_text.replace(f"<tmp>{i.get('tag_name')}</tmp>", process_content(i))
+    return file_text

pyact_cli-0.5.0/pyact/css2json.py

@@ -0,0 +1,79 @@
+import re
+import json
+
+def css_to_dict(css_string: str) -> dict:
+    """
+    Parses a raw CSS string into a nested Python dictionary.
+    
+    Why it is needed:
+    CSS is text-based and formatted with selectors, curly braces, and semicolons.
+    To programmatically apply these styles to python-docx elements, we need to 
+    convert the syntax into a highly structured, queryable dictionary map.
+    
+    Inputs:
+        css_string (str): The raw contents of a CSS file as a string.
+        
+    Outputs:
+        dict: A dictionary where keys are CSS selectors (e.g., 'p', 'h1') and 
+              values are dictionaries of style properties (e.g., {'color': '#000'}).
+    """
+    # Remove CSS comments
+    css_string = re.sub(r'/\*[\s\S]*?\*/', '', css_string)
+    
+    # Match selectors and their corresponding blocks
+    pattern = r'([^{]+)\{([^}]+)\}'
+    matches = re.findall(pattern, css_string)
+    
+    css_dict = {}
+    for selector, block in matches:
+        selector = selector.strip()
+        
+        # Parse individual CSS properties
+        rules = {}
+        for line in block.split(';'):
+            line = line.strip()
+            if not line:
+                continue
+            if ':' in line:
+                key, val = line.split(':', 1)
+                rules[key.strip()] = val.strip()
+        
+        # Handle comma-separated selectors (e.g., 'h1, h2, h3')
+        for sel in selector.split(','):
+            sel = sel.strip()
+            if sel:
+                if sel not in css_dict:
+                    css_dict[sel] = {}
+                css_dict[sel].update(rules)
+                
+    return css_dict
+
+def parse_css_file(file_path: str, as_json_string: bool = False):
+    """
+    Reads a CSS file from disk and parses it into a dictionary or JSON string.
+    
+    Why it is needed:
+    Provides a clean interface for reading a physical file from the OS, extracting 
+    its contents, and piping it into the core `css_to_dict` parser.
+    
+    Inputs:
+        file_path (str): The path to the `.css` file on disk.
+        as_json_string (bool): If True, returns the output as a serialized JSON string 
+                               instead of a Python dictionary. Defaults to False.
+                               
+    Outputs:
+        dict or str: The parsed CSS dictionary, or a JSON-formatted string if requested.
+    """
+    with open(file_path, 'r', encoding='utf-8') as f:
+        css_string = f.read()
+    
+    css_dict = css_to_dict(css_string)
+    
+    if as_json_string:
+        return json.dumps(css_dict, indent=4)
+    return css_dict
+
+if __name__ == "__main__":
+    # Example usage:
+    # print(parse_css_file("style.css", as_json_string=True))
+    pass

pyact_cli-0.5.0/pyact/mdTOword.py

@@ -0,0 +1,467 @@
+import re
+from docx import Document
+from docx.shared import Pt, RGBColor
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.oxml import parse_xml
+from docx.oxml.ns import nsdecls
+import math2docx
+from . import css2json
+
+def style_parser(css_path: str) -> dict:
+    """
+    Parses a CSS file and converts it into a Python dictionary containing style maps.
+    
+    Why it is needed:
+    To allow users to style their exported Word Documents using standard CSS syntax, 
+    we must first translate that CSS into a structured Python dictionary that the 
+    DOCX generation engine can query.
+    
+    Inputs:
+        css_path (str): The absolute or relative file path to the target .css file.
+        
+    Outputs:
+        dict: A nested dictionary where keys are CSS selectors (e.g., 'h1', 'p') 
+              and values are dictionaries of property-value pairs (e.g., {'color': '#000', 'font-size': '12pt'}).
+              Returns an empty dictionary {} if parsing fails.
+    """
+    try:
+        return css2json.parse_css_file(css_path)
+    except Exception as e:
+        print(f"Warning: Could not parse CSS ({e})")
+        return {}
+
+def markdown_parser(md_text: str) -> list:
+    """
+    Parses raw Markdown text into a structured list of block tuples.
+    
+    Why it is needed:
+    Because python-docx generates documents block-by-block (paragraphs, tables, headings), 
+    we need to break down the raw string of Markdown text into distinct, classified chunks 
+    that our DOCX writer can loop through and translate into native Word elements.
+    
+    Inputs:
+        md_text (str): The complete raw Markdown text string.
+        
+    Outputs:
+        list: A list of tuples where each tuple represents a block element.
+              Examples: 
+              - ('heading', 2, 'Title Text')
+              - ('paragraph', 'Some plain text')
+              - ('list', 'List item text', 'ordered')
+              - ('math', 'x = 2')
+              - ('table', ['|Header|', '|---|', '|Data|'])
+    """
+    blocks = []
+    lines = md_text.split('\n')
+    
+    current_table = []
+    
+    for line in lines:
+        line_s = line.strip()
+        
+        # Table Parsing
+        if line_s.startswith('|') and line_s.endswith('|'):
+            current_table.append(line_s)
+            continue
+        elif current_table:
+            blocks.append(('table', current_table))
+            current_table = []
+            
+        if not line_s:
+            continue
+            
+        # Heading Parsing
+        if line_s.startswith('#'):
+            level = len(line_s) - len(line_s.lstrip('#'))
+            text = line_s.lstrip('#').strip()
+            blocks.append(('heading', level, text))
+            
+        # List Parsing
+        elif line_s.startswith('- ') or line_s.startswith('* '):
+            text = line_s[2:].strip()
+            blocks.append(('list', text, 'unordered'))
+            
+        elif re.match(r'^\d+\.\s+', line_s):
+            m = re.match(r'^\d+\.\s+(.*)', line_s)
+            blocks.append(('list', m.group(1), 'ordered'))
+            
+        # Math Block Parsing
+        elif line_s.startswith('$$') and line_s.endswith('$$'):
+            blocks.append(('math', line_s.strip('$').strip()))
+            
+        # Standard Paragraph
+        else:
+            blocks.append(('paragraph', line_s))
+            
+    if current_table:
+        blocks.append(('table', current_table))
+        
+    return blocks
+
+def _apply_css_to_run(run, css_rules):
+    """Helper to apply CSS rules to a docx run or font."""
+    font = run.font if hasattr(run, 'font') else run
+    
+    if 'color' in css_rules:
+        hex_col = css_rules['color'].replace('#', '').strip()
+        if len(hex_col) == 6:
+            try:
+                r, g, b = tuple(int(hex_col[i:i+2], 16) for i in (0, 2, 4))
+                font.color.rgb = RGBColor(r, g, b)
+            except ValueError:
+                pass
+                
+    if 'font-size' in css_rules:
+        size = css_rules['font-size'].replace('pt', '').strip()
+        try:
+            font.size = Pt(float(size))
+        except ValueError:
+            pass
+            
+    if 'font-family' in css_rules:
+        font.name = css_rules['font-family'].strip("'\"")
+        
+    if 'font-weight' in css_rules:
+        font.bold = (css_rules['font-weight'].lower() == 'bold')
+        
+    if 'font-style' in css_rules:
+        font.italic = (css_rules['font-style'].lower() == 'italic')
+        
+    if 'text-decoration' in css_rules:
+        dec = css_rules['text-decoration'].lower()
+        if dec == 'underline':
+            font.underline = True
+        elif dec == 'line-through':
+            font.strike = True
+        elif dec == 'none':
+            font.underline = False
+            font.strike = False
+            
+    if 'text-transform' in css_rules:
+        trans = css_rules['text-transform'].lower()
+        if trans == 'uppercase':
+            font.all_caps = True
+        elif trans == 'small-caps':
+            font.small_caps = True
+            
+    if 'background-color' in css_rules:
+        # Maps text background to highlight color index
+        from docx.enum.text import WD_COLOR_INDEX
+        color_map = {
+            'auto': WD_COLOR_INDEX.AUTO, 'black': WD_COLOR_INDEX.BLACK, 'blue': WD_COLOR_INDEX.BLUE,
+            'bright-green': WD_COLOR_INDEX.BRIGHT_GREEN, 'dark-blue': WD_COLOR_INDEX.DARK_BLUE,
+            'dark-red': WD_COLOR_INDEX.DARK_RED, 'dark-yellow': WD_COLOR_INDEX.DARK_YELLOW,
+            'gray-25': WD_COLOR_INDEX.GRAY_25, 'gray-50': WD_COLOR_INDEX.GRAY_50,
+            'green': WD_COLOR_INDEX.GREEN, 'pink': WD_COLOR_INDEX.PINK, 'red': WD_COLOR_INDEX.RED,
+            'teal': WD_COLOR_INDEX.TEAL, 'turquoise': WD_COLOR_INDEX.TURQUOISE,
+            'violet': WD_COLOR_INDEX.VIOLET, 'white': WD_COLOR_INDEX.WHITE, 'yellow': WD_COLOR_INDEX.YELLOW
+        }
+        bg_col = css_rules['background-color'].lower()
+        if bg_col in color_map:
+            font.highlight_color = color_map[bg_col]
+
+def _apply_paragraph_formatting(p, css_rules):
+    """Helper to apply CSS rules to paragraph formatting."""
+    fmt = p.paragraph_format
+    
+    if 'text-align' in css_rules:
+        align = css_rules['text-align'].lower()
+        if align == 'center':
+            p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+        elif align == 'right':
+            p.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+        elif align == 'justify':
+            p.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
+        elif align == 'distribute':
+            p.alignment = WD_ALIGN_PARAGRAPH.DISTRIBUTE
+        elif align == 'left':
+            p.alignment = WD_ALIGN_PARAGRAPH.LEFT
+            
+    if 'margin-top' in css_rules:
+        val = css_rules['margin-top'].replace('pt', '').strip()
+        try:
+            fmt.space_before = Pt(float(val))
+        except ValueError:
+            pass
+            
+    if 'margin-bottom' in css_rules:
+        val = css_rules['margin-bottom'].replace('pt', '').strip()
+        try:
+            fmt.space_after = Pt(float(val))
+        except ValueError:
+            pass
+            
+    if 'line-height' in css_rules:
+        try:
+            fmt.line_spacing = float(css_rules['line-height'])
+        except ValueError:
+            pass
+            
+    if 'page-break-before' in css_rules:
+        if css_rules['page-break-before'].lower() == 'always':
+            fmt.page_break_before = True
+
+import docx.opc.constants
+from docx.oxml.shared import OxmlElement, qn
+import urllib.request
+import io
+import random
+
+def _add_internal_hyperlink(paragraph, text, anchor):
+    """Adds a clickable internal hyperlink to a bookmark anchor in the docx."""
+    hyperlink = OxmlElement('w:hyperlink')
+    hyperlink.set(qn('w:anchor'), anchor)
+    
+    new_run = OxmlElement('w:r')
+    rPr = OxmlElement('w:rPr')
+    
+    # Make it superscript since it's usually a footnote marker
+    vertAlign = OxmlElement('w:vertAlign')
+    vertAlign.set(qn('w:val'), 'superscript')
+    rPr.append(vertAlign)
+    
+    # Make it blue
+    c = OxmlElement('w:color')
+    c.set(qn('w:val'), '0563C1')
+    rPr.append(c)
+    
+    new_run.append(rPr)
+    
+    text_elem = OxmlElement('w:t')
+    text_elem.text = text
+    new_run.append(text_elem)
+    
+    hyperlink.append(new_run)
+    paragraph._p.append(hyperlink)
+
+def _add_bookmark(paragraph, text, anchor):
+    """Creates a bookmark anchor in the document and places text inside it."""
+    # We need a random ID to prevent collisions
+    bm_id = str(random.randint(10000, 99999))
+    
+    bm_start = OxmlElement('w:bookmarkStart')
+    bm_start.set(qn('w:id'), bm_id)
+    bm_start.set(qn('w:name'), anchor)
+    paragraph._p.append(bm_start)
+    
+    run = paragraph.add_run(text)
+    
+    bm_end = OxmlElement('w:bookmarkEnd')
+    bm_end.set(qn('w:id'), bm_id)
+    paragraph._p.append(bm_end)
+    return run
+
+def _add_hyperlink(paragraph, text, url, styles, tag):
+    """Adds a real hyperlink to a docx paragraph."""
+    part = paragraph.part
+    r_id = part.relate_to(url, docx.opc.constants.RELATIONSHIP_TYPE.HYPERLINK, is_external=True)
+    
+    hyperlink = OxmlElement('w:hyperlink')
+    hyperlink.set(qn('r:id'), r_id)
+    
+    new_run = OxmlElement('w:r')
+    rPr = OxmlElement('w:rPr')
+    
+    c = OxmlElement('w:color')
+    if 'hyperlink' in styles and 'color' in styles['hyperlink']:
+        color_hex = styles['hyperlink']['color'].replace('#', '').strip()
+        c.set(qn('w:val'), color_hex)
+    else:
+        c.set(qn('w:val'), '0563C1')
+    rPr.append(c)
+    
+    u = OxmlElement('w:u')
+    if 'hyperlink' in styles and 'text-decoration' in styles['hyperlink'] and styles['hyperlink']['text-decoration'] == 'none':
+        pass
+    else:
+        u.set(qn('w:val'), 'single')
+        rPr.append(u)
+        
+    new_run.append(rPr)
+    
+    text_elem = OxmlElement('w:t')
+    text_elem.text = text
+    new_run.append(text_elem)
+    
+    hyperlink.append(new_run)
+    paragraph._p.append(hyperlink)
+
+def _add_image(paragraph, url, caption, styles):
+    """Adds an inline image fetched from URL."""
+    try:
+        req = urllib.request.Request(url, headers={'User-Agent': 'Mozilla/5.0'})
+        with urllib.request.urlopen(req) as response:
+            image_stream = io.BytesIO(response.read())
+        
+        run = paragraph.add_run()
+        
+        # Apply CSS dimensions if available
+        width = None
+        if 'image' in styles and 'width' in styles['image']:
+            w_str = styles['image']['width']
+            if 'in' in w_str: width = docx.shared.Inches(float(w_str.replace('in', '').strip()))
+            
+        if width:
+            run.add_picture(image_stream, width=width)
+        else:
+            run.add_picture(image_stream, width=docx.shared.Inches(4))
+            
+    except Exception as e:
+        paragraph.add_run(f"[Image Failed: {url}]")
+
+def _process_inline(paragraph, text, styles, tag):
+    """Parses text for images, links, math, and bold/italic."""
+    # Simple regex to split by math, image, or link. Captures the match as a group.
+    # Group 5: Footnote definition [^1]: ...
+    # Group 6: Footnote annotation [^1]
+    pattern = r'(\$\$.*?\$\$)|(!\[.*?\]\(.*?\))|(\[.*?\]\(.*?\))|(<span.*?>.*?</span>)|(\[\^.*?\]:.*?$)|(\[\^.*?\])'
+    parts = re.split(pattern, text)
+    
+    for part in parts:
+        if not part: continue
+        
+        if part.startswith('$$') and part.endswith('$$'):
+            math_text = part.strip('$').strip()
+            try:
+                math2docx.add_math(paragraph, math_text)
+            except Exception:
+                run = paragraph.add_run(part)
+                if tag in styles: _apply_css_to_run(run, styles[tag])
+                
+        elif part.startswith('![') and part.endswith(')'):
+            m = re.match(r'!\[(.*?)\]\((.*?)\)', part)
+            if m:
+                _add_image(paragraph, m.group(2), m.group(1), styles)
+                
+        elif part.startswith('[') and part.endswith(')'):
+            m = re.match(r'\[(.*?)\]\((.*?)\)', part)
+            if m:
+                _add_hyperlink(paragraph, m.group(1), m.group(2), styles, tag)
+                
+        elif part.startswith('<span') and part.endswith('</span>'):
+            m = re.match(r'<span.*?>(.*?)</span>', part)
+            if m:
+                caption_text = m.group(1)
+                run = paragraph.add_run(caption_text)
+                run.italic = True
+                paragraph.alignment = docx.enum.text.WD_ALIGN_PARAGRAPH.CENTER
+                if tag in styles: _apply_css_to_run(run, styles[tag])
+                
+        elif part.startswith('[^') and ']:' in part:
+            # Footnote definition e.g. [^1]: The text
+            m = re.match(r'\[\^(.*?)\]:\s*(.*)', part)
+            if m:
+                fn_id = m.group(1)
+                fn_text = m.group(2)
+                # Create a bookmark here for the annotation to jump to
+                run = _add_bookmark(paragraph, f"[{fn_id}]: {fn_text}", f"footnote_{fn_id}")
+                if tag in styles: _apply_css_to_run(run, styles[tag])
+                
+        elif part.startswith('[^') and part.endswith(']'):
+            # Footnote annotation e.g. [^1]
+            m = re.match(r'\[\^(.*?)\]', part)
+            if m:
+                fn_id = m.group(1)
+                _add_internal_hyperlink(paragraph, f"[{fn_id}]", f"footnote_{fn_id}")
+                
+        else:
+            # Handle plain text + bold/italic
+            subparts = re.split(r'(\*\*.*?\*\*|\*.*?\*)', part)
+            for subpart in subparts:
+                if not subpart: continue
+                if subpart.startswith('**') and subpart.endswith('**'):
+                    run = paragraph.add_run(subpart[2:-2])
+                    run.bold = True
+                    if tag in styles: _apply_css_to_run(run, styles[tag])
+                elif subpart.startswith('*') and subpart.endswith('*'):
+                    run = paragraph.add_run(subpart[1:-1])
+                    run.italic = True
+                    if tag in styles: _apply_css_to_run(run, styles[tag])
+                else:
+                    run = paragraph.add_run(subpart)
+                    if tag in styles: _apply_css_to_run(run, styles[tag])
+
+def docx_writer(blocks: list, styles: dict, output_file: str):
+    """
+    Translates parsed markdown blocks into a Word document and applies CSS styling.
+    
+    Why it is needed:
+    This is the core generation engine. It takes the abstract syntax structure generated 
+    by `markdown_parser()` and the style rules from `style_parser()`, loops through them, 
+    and issues the corresponding `python-docx` commands to physically build the `.docx` file.
+    
+    Inputs:
+        blocks (list): The list of parsed Markdown block tuples (from `markdown_parser`).
+        styles (dict): The nested dictionary of CSS rules (from `style_parser`).
+        output_file (str): The absolute or relative file path where the resulting .docx should be saved.
+        
+    Outputs:
+        None: This function does not return a value, but it writes a binary .docx file to disk.
+    """
+    doc = Document()
+    
+    # Global body style
+    if 'body' in styles:
+        normal_style = doc.styles['Normal']
+        _apply_css_to_run(normal_style, styles['body'])
+        _apply_paragraph_formatting(normal_style, styles['body'])
+
+    for block in blocks:
+        btype = block[0]
+        
+        if btype == 'heading':
+            level, text = block[1], block[2]
+            p = doc.add_heading('', level=level)
+            _process_inline(p, text, styles, f'h{level}')
+            if f'h{level}' in styles:
+                _apply_paragraph_formatting(p, styles[f'h{level}'])
+                
+        elif btype == 'paragraph':
+            text = block[1]
+            p = doc.add_paragraph()
+            if 'p' in styles:
+                _apply_paragraph_formatting(p, styles['p'])
+            _process_inline(p, text, styles, 'p')
+                
+        elif btype == 'list':
+            text = block[1]
+            list_type = block[2] if len(block) > 2 else 'unordered'
+            style = 'List Number' if list_type == 'ordered' else 'List Bullet'
+            p = doc.add_paragraph(style=style)
+            if 'list' in styles:
+                _apply_paragraph_formatting(p, styles['list'])
+            _process_inline(p, text, styles, 'list')
+                
+        elif btype == 'math':
+            math_text = block[1]
+            p = doc.add_paragraph()
+            try:
+                math2docx.add_math(p, math_text)
+                if 'equation' in styles:
+                    _apply_paragraph_formatting(p, styles['equation'])
+            except Exception:
+                p.add_run(f"$$ {math_text} $$")
+                
+        elif btype == 'table':
+            table_lines = block[1]
+            rows = [
+                [cell.strip() for cell in line.strip('|').split('|')]
+                for line in table_lines if '---' not in line
+            ]
+            if rows:
+                table = doc.add_table(rows=len(rows), cols=len(rows[0]))
+                for r_idx, row in enumerate(rows):
+                    for c_idx, val in enumerate(row):
+                        table.cell(r_idx, c_idx).text = val
+                if 'table' in styles:
+                    pass
+
+    doc.save(output_file)
+
+
+if __name__ == "__main__":
+    # Example Usage:
+    styles = style_parser('engine/style.css')
+    md_blocks = markdown_parser('## Hello World\nThis is a **bold** test.')
+    docx_writer(md_blocks, styles, 'output.docx')
+    

{pyact_cli-0.3.0 → pyact_cli-0.5.0}/pyact_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyact-cli
-Version: 0.3.0
+Version: 0.5.0
 Summary: A CLI tool to compile .pamd files to Markdown.
 Home-page: https://github.com/Abstergo2003/PyAct
 Author: Abstergo2003
@@ -65,10 +65,17 @@ You can also include other pamd files as templates!
 <tmp>path/to/another_file</tmp>
 ```
 
-### 3. Compile!
+### 3. Compile to Markdown
 Run the compiler from your terminal to generate your final Markdown document:
 ```bash
 pyact path/to/your_file.pamd -o output.md
 ```
 
-That's it! You now have a standard Markdown file ready to be shared, published, or converted to PDF.
+### 4. Compile to Word (DOCX)
+You can also compile straight to a native Microsoft Word Document, complete with CSS styling! 
+```bash
+pyact path/to/your_file.pamd -o output.md --docx output.docx
+```
+*Note: If you have a `style.css` file in the same directory, PyAct will automatically load it to style your Word Document. You can also specify one manually using the `--css path/to/style.css` flag!*
+
+That's it! You now have documents ready to be shared, published, or distributed.

{pyact_cli-0.3.0 → pyact_cli-0.5.0}/pyact_cli.egg-info/SOURCES.txt

@@ -4,6 +4,8 @@ pamd_helpers/__init__.py
 pyact/__init__.py
 pyact/cli.py
 pyact/core.py
+pyact/css2json.py
+pyact/mdTOword.py
 pyact/py2tex.py
 pyact_cli.egg-info/PKG-INFO
 pyact_cli.egg-info/SOURCES.txt

{pyact_cli-0.3.0 → pyact_cli-0.5.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="pyact-cli",
-    version="0.3.0",
+    version="0.5.0",
     author="Abstergo2003",
     author_email="",
     description="A CLI tool to compile .pamd files to Markdown.",

pyact_cli-0.3.0/pamd_helpers/__init__.py

@@ -1,76 +0,0 @@
-import inspect
-from pyact.py2tex import py2tex
-
-def equation(func: function, values: list) -> str:
-    source = inspect.getsource(func)
-    value = func(*values)
-    name, sep, tail = source.rpartition("=")
-    head, sep, equ = tail.rpartition(":")
-    return f"$$ {name} = {py2tex(equ.replace("\n", ""))} = {value} $$"
-
-
-def image(link: str, caption: str) -> str:
-    image_link = f"![{caption}]({link})"
-    caption = f"<span style='text-align: center; display: block; font-style: italic;'>{caption}</span>"
-    return f"{image_link} \n {caption}"
-
-def table(headers: list, values: list, caption: str, add_no: bool = False, starting_number: int = 1) -> str:
-    if add_no:
-        headers_string = f"|No.|"
-        breaker_line = "|---|"
-    else:
-        headers_string = f"|"
-        breaker_line = "|"
-
-
-    for i in headers:
-        headers_string += f"{i}|"
-        breaker_line += "-"*len(i)+"|"
-
-    table_content = ""
-
-    for i, row in enumerate(values):
-        if add_no:
-            table_content += f"|{i+starting_number}|"
-        else:
-            table_content += "|"
-
-        for value in row:
-            table_content += f"{value}|"
-        table_content += "\n"
-
-    caption = f"<span style='text-align: center; display: block; font-style: italic;'>{caption}</span>"
-    return f"{caption} \n {headers_string}\n{breaker_line}\n{table_content}"
-
-
-def hyperlink(caption: str, link: str) -> str:
-    return f"[{caption}]({link})"
-
-def unordered_list(items: list) -> str:
-    list_string = ""
-    for i in items:
-        list_string += f"* {i}\n"
-    return list_string
-
-def ordered_list(items: list) -> str:
-    list_string = ""
-    for i, item in enumerate(items):
-        list_string += f"{i+1}. {item}\n"
-    return list_string
-
-def checklist(items: list) -> str:
-    list_string = ""
-    for i in items:
-        list_string += f"- [ ] {i}\n"
-    return list_string
-
-class Footnote:
-    def __init__(self, number, text):
-        self.number = number
-        self.text = text
-
-    def define_string(self) -> str:
-        return f"[^{self.number}]: {self.text}"
-
-    def adnotation(self) -> str:
-        return f"[^{self.number}]\n"

pyact_cli-0.3.0/pyact/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.0"

pyact_cli-0.3.0/pyact/cli.py

@@ -1,35 +0,0 @@
-import argparse
-import sys
-import os
-from .core import map_content, process_content
-
-def main():
-    parser = argparse.ArgumentParser(description="PyAct CLI - PAMD to Markdown compiler")
-    parser.add_argument("input", help="Path to the main .pamd file")
-    parser.add_argument("-o", "--output", help="Output file path (default prints to stdout)")
-    
-    args = parser.parse_args()
-    
-    input_path = os.path.abspath(args.input)
-    directory = os.path.dirname(input_path)
-    filename = os.path.basename(input_path)
-    
-    if filename.endswith(".pamd"):
-        filename = filename[:-5]
-        
-    try:
-        build_tree = map_content(filename, directory)
-        content = process_content(build_tree)
-        
-        if args.output:
-            with open(args.output, "w", encoding="utf-8") as f:
-                f.write(content)
-            print(f"Successfully compiled to {args.output}")
-        else:
-            print(content)
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()

pyact_cli-0.3.0/pyact/core.py

@@ -1,103 +0,0 @@
-import re
-import json
-
-def get_directory(path: str) -> list:
-    # Splits path into: ('./main', '/', 'retro.pamd')
-    head, sep, tail = path.rpartition('/')
-    # Recombine the first part and the slash
-    return [head + sep, tail]
-
-def read_pamd_cells(file_path: str):
-    with open(file_path, 'r', encoding='utf-8') as f:
-        data = json.load(f)
-    
-    code_content = ""
-    markdown_content = ""
-    
-    for cell in data.get("cells", []):
-        cell_type = cell.get("cell_type", "")
-        source = cell.get("source", "")
-        if isinstance(source, list):
-            source = "".join(source)
-            
-        if cell_type == "code":
-            code_content += source + "\n"
-        elif cell_type == "markdown":
-            markdown_content += source + "\n"
-            
-    return code_content, markdown_content
-
-def get_imports(file: str, code_text: str):
-    file_namespace = {"__file__": f"{file}.pamd"}
-    if not code_text.strip():
-        raise ValueError(f"The file {file}.pamd needs a 'context()' function but has no code cell.")
-        
-    try:
-        exec(code_text, file_namespace)
-    except Exception as e:
-        raise RuntimeError(f"Error executing code in {file}.pamd: {e}")
-
-    if "context" not in file_namespace:
-        raise ValueError(f"The file {file}.pamd is missing the required 'context()' function.")
-
-    context_func = file_namespace["context"]
-
-    if not callable(context_func):
-        raise TypeError(f"In {file}.pamd, 'context' was found but it is not a function!")
-
-    result_dict = context_func()
-
-    if not isinstance(result_dict, dict):
-        raise TypeError(f"The 'context()' function in {file}.pamd must return a dictionary.")
-
-    return result_dict
-
-def find_imports(text: str):
-    # <ctx></ctx>
-    pattern = r"<ctx>(.*?)</ctx>"
-    return re.findall(pattern, text)
-
-
-def find_templates(text: str):
-    # <tmp></tmp>
-    pattern = r"<tmp>(.*?)</tmp>"
-    return re.findall(pattern, text)
-
-def map_content(file: str, path: str):
-    if path and not path.endswith('/'):
-        full_path = f"{path}/{file}"
-    elif path.endswith('/'):
-        full_path = f"{path}{file}"
-    else:
-        full_path = file
-        
-    code_text, main_file = read_pamd_cells(f"{full_path}.pamd")
-    templates = find_templates(main_file)
-    imports = find_imports(main_file)
-    meta = get_directory(full_path)
-    
-    ready_t = []
-    for i in templates:
-        ready_t.append(map_content(i, meta[0]))
-
-    return {
-        "tag_name": file,
-        "name": meta[1],
-        "path": meta[0],
-        "imports": imports,
-        "templates": ready_t
-    }
-
-def process_content(build_tree: dict):
-    file_path_base = build_tree.get("path", "") + build_tree.get("name", "")
-    code_text, file_text = read_pamd_cells(file_path_base + ".pamd")
-    
-    needed_imports = build_tree.get("imports", [])
-    if needed_imports:
-        imports = get_imports(file_path_base, code_text)
-        for i in needed_imports:
-            file_text = file_text.replace(f"<ctx>{i}</ctx>", str(imports.get(i, '')))
-
-    for i in build_tree.get("templates", []):
-        file_text = file_text.replace(f"<tmp>{i.get('tag_name')}</tmp>", process_content(i))
-    return file_text