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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyact-cli
-Version: 0.4.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.4.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.4.0 → pyact_cli-0.5.0}/pyact/cli.py

@@ -4,6 +4,24 @@ 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)")

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.4.0 → pyact_cli-0.5.0}/pyact/css2json.py

@@ -2,7 +2,21 @@ import re
 import json
 
 def css_to_dict(css_string: str) -> dict:
-    """Parses a CSS string into a Python dictionary."""
+    """
+    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)
     
@@ -36,8 +50,19 @@ def css_to_dict(css_string: str) -> dict:
 
 def parse_css_file(file_path: str, as_json_string: bool = False):
     """
-    Reads a CSS file and converts it to a dictionary map. 
-    If as_json_string is True, returns a formatted JSON string instead.
+    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()

{pyact_cli-0.4.0 → pyact_cli-0.5.0}/pyact/mdTOword.py

@@ -7,9 +7,22 @@ from docx.oxml.ns import nsdecls
 import math2docx
 from . import css2json
 
-def style_parser(css_path):
+def style_parser(css_path: str) -> dict:
     """
-    Reads a CSS file and converts it into a style dictionary using css2json.
+    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)
@@ -17,10 +30,26 @@ def style_parser(css_path):
         print(f"Warning: Could not parse CSS ({e})")
         return {}
 
-def markdown_parser(md_text):
+def markdown_parser(md_text: str) -> list:
     """
-    Parses Markdown text into a list of structured blocks.
-    Supported blocks: heading, paragraph, list, table, math
+    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')
@@ -355,6 +384,19 @@ def _process_inline(paragraph, text, 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()
     

{pyact_cli-0.4.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.4.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.4.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.4.0",
+    version="0.5.0",
     author="Abstergo2003",
     author_email="",
     description="A CLI tool to compile .pamd files to Markdown.",

pyact_cli-0.4.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.4.0/pyact/__init__.py

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

pyact_cli-0.4.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