pyact-cli 1.0.0__tar.gz → 1.2.0__tar.gz

{pyact_cli-1.0.0 → pyact_cli-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyact-cli
-Version: 1.0.0
+Version: 1.2.0
 Summary: A CLI tool to compile .pamd files to Markdown.
 Home-page: https://github.com/Abstergo2003/PyAct
 Author: Abstergo2003
@@ -37,7 +37,8 @@ pip install pyact-cli
 
 ## 📖 How it works
 
-A `.pamd` file is split into a **Python cell** and a **Markdown cell**. 
+A `.pamd` file contains exactly one **Markdown cell** and may contain multiple
+**Python cells**. Python cells are concatenated in order before execution.
 
 ### 1. Write your Python logic
 Define a `context()` function that returns the variables you want to inject. You can even use the built-in `pamd_helpers` to do heavy lifting!
@@ -86,6 +87,14 @@ Run the compiler from your terminal to generate your final Markdown document:
 pyact path/to/your_file.pamd -o output.md
 ```
 
+Use `--no-cache` to force a rebuild without reading cached Markdown, or
+`--clear-cache` to remove the project's `.pamd-cache` directory before building:
+
+```bash
+pyact path/to/your_file.pamd --no-cache
+pyact path/to/your_file.pamd --clear-cache
+```
+
 ### 5. Compile to Word (DOCX)
 You can also compile straight to a native Microsoft Word Document, complete with CSS styling! 
 ```bash

{pyact_cli-1.0.0 → pyact_cli-1.2.0}/README.md

@@ -14,7 +14,8 @@ pip install pyact-cli
 
 ## 📖 How it works
 
-A `.pamd` file is split into a **Python cell** and a **Markdown cell**. 
+A `.pamd` file contains exactly one **Markdown cell** and may contain multiple
+**Python cells**. Python cells are concatenated in order before execution.
 
 ### 1. Write your Python logic
 Define a `context()` function that returns the variables you want to inject. You can even use the built-in `pamd_helpers` to do heavy lifting!
@@ -63,6 +64,14 @@ Run the compiler from your terminal to generate your final Markdown document:
 pyact path/to/your_file.pamd -o output.md
 ```
 
+Use `--no-cache` to force a rebuild without reading cached Markdown, or
+`--clear-cache` to remove the project's `.pamd-cache` directory before building:
+
+```bash
+pyact path/to/your_file.pamd --no-cache
+pyact path/to/your_file.pamd --clear-cache
+```
+
 ### 5. Compile to Word (DOCX)
 You can also compile straight to a native Microsoft Word Document, complete with CSS styling! 
 ```bash

{pyact_cli-1.0.0 → pyact_cli-1.2.0}/pamd_helpers/__init__.py

@@ -1,7 +1,46 @@
 import inspect
+import ast
+import textwrap
 from typing import Callable, List, Any
+from enum import Enum
 from pyact.py2tex import py2tex
 
+
+def _extract_lambda_parts(func: Callable) -> tuple[str, list[str], str]:
+    source = textwrap.dedent(inspect.getsource(func))
+    tree = ast.parse(source)
+    lambda_node = next(
+        (node for node in ast.walk(tree) if isinstance(node, ast.Lambda)),
+        None,
+    )
+    if lambda_node is None:
+        raise ValueError("Expected a lambda function.")
+
+    expression = ast.get_source_segment(source, lambda_node.body)
+    if expression is None:
+        raise ValueError("Could not read the lambda expression.")
+
+    name = getattr(func, "__name__", "calculation")
+    assignment = next(
+        (
+            node
+            for node in ast.walk(tree)
+            if isinstance(node, ast.Assign)
+            and any(isinstance(target, ast.Name) for target in node.targets)
+            and lambda_node in ast.walk(node.value)
+        ),
+        None,
+    )
+    if assignment is not None:
+        name = next(
+            target.id
+            for target in assignment.targets
+            if isinstance(target, ast.Name)
+        )
+
+    variables = [argument.arg for argument in lambda_node.args.args]
+    return name, variables, expression
+
 def equation(func: Callable, values: List[Any]) -> str:
     """
     Converts a Python lambda or simple function into a LaTeX math equation string.
@@ -17,10 +56,9 @@ def equation(func: Callable, values: List[Any]) -> str:
     Outputs:
         str: A Markdown math string formatted as `$$ Name = Equation = Value $$`.
     """
-    source = inspect.getsource(func)
+    print("Function 'equation()' is deprecated and will be removed, please use Calculation() class.")
     value = func(*values)
-    name, sep, tail = source.rpartition("=")
-    head, sep, equ = tail.rpartition(":")
+    name, _, equ = _extract_lambda_parts(func)
     
     name = name.strip()
     if "_" in name:
@@ -139,6 +177,7 @@ def table(headers: List[str], values: List[List[Any]], caption: str, add_no: boo
     Outputs:
         str: A formatted Markdown string containing the caption and the table.
     """
+    print("Function 'table()' is deprecated and will be removed, please use Table() class.")
     if add_no:
         headers_string = f"|No.|"
         breaker_line = "|---|"
@@ -192,6 +231,7 @@ def unordered_list(items: List[str]) -> str:
     Outputs:
         str: A Markdown string where each item is prefixed with `* `.
     """
+    print("Function 'unordered_list()' is deprecated and will be removed, please use CList() class.")
     list_string = ""
     for i in items:
         list_string += f"* {i}\n"
@@ -210,6 +250,7 @@ def ordered_list(items: List[str]) -> str:
     Outputs:
         str: A Markdown string where each item is numbered sequentially (1. 2. 3.).
     """
+    print("Function 'ordered_list()' is deprecated and will be removed, please use CList() class.")
     list_string = ""
     for i, item in enumerate(items):
         list_string += f"{i+1}. {item}\n"
@@ -228,6 +269,7 @@ def checklist(items: List[str]) -> str:
     Outputs:
         str: A Markdown string where each item is prefixed with `- [ ] `.
     """
+    print("Function 'checklist()' is deprecated and will be removed, please use CList() class.")
     list_string = ""
     for i in items:
         list_string += f"- [ ] {i}\n"
@@ -251,6 +293,9 @@ class Footnote:
         self.number = number
         self.text = text
 
+    def __repr__(self) -> str:
+        return self.define_string()
+
     def define_string(self) -> str:
         """
         Outputs (str): The full footnote definition block to place at the bottom of the document.
@@ -282,6 +327,7 @@ def table_to_dxf(headers: List[str], values: List[List[Any]], filename: str, cel
     Outputs:
         str: A string confirming the export, formatted as a Markdown link.
     """
+    print("Function 'table_to_dfx()' is deprecated and will be removed, please use Table() class.")
     try:
         import ezdxf
     except ImportError:
@@ -319,4 +365,225 @@ def table_to_dxf(headers: List[str], values: List[List[Any]], filename: str, cel
             ).set_placement((x, y), align=ezdxf.enums.TextEntityAlignment.MIDDLE_CENTER)
             
     doc.saveas(filename)
-    return f"*[Successfully exported table to {filename}]({filename})*"
+    return f"*[Successfully exported table to {filename}]({filename})*"
+
+class Calculation:
+    def __init__(self, func: Callable, values: List[float|int], repl: bool = False, precision: int = 3):
+        self.func = func
+        self.values = values
+        self.replace = repl
+        self.precision = precision
+        self.value = round(func(*values), self.precision)
+        self.name = None
+        self.vars = None
+        self.repr = self.get_representation()
+
+    def __repr__(self):
+        return self.repr
+
+    def recalculate(self, values, precision: int = None):
+        if precision is None:
+            return Calculation(self.func, values, self.replace, self.precision)
+        else:
+            return Calculation(self.func, values, self.replace, precision)
+
+    def get_representation(self):
+        name, self.vars, equ = _extract_lambda_parts(self.func)
+        
+        name = name.strip()
+        self.name = f"$ {py2tex(name)} $"
+        if "_" in name:
+            parts = name.split("_", 1)
+            name = f"{parts[0]}_{{{parts[1]}}}"
+            
+        import re
+        greek_pattern = r'(?<![a-zA-Z])(alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega|Alpha|Beta|Gamma|Delta|Epsilon|Zeta|Eta|Theta|Iota|Kappa|Lambda|Mu|Nu|Xi|Omicron|Pi|Rho|Sigma|Tau|Upsilon|Phi|Chi|Psi|Omega)(?![a-zA-Z])'
+        name = re.sub(greek_pattern, r'\\\1', name)
+        texified = py2tex(equ.replace(chr(10), ''))
+        replaced = texified
+        for i, vr in enumerate(self.vars):
+            replaced = replaced.replace(py2tex(vr.replace(",", "")), f"{self.values[i]}")
+
+        if self.replace:
+            return f"$$ {name} = {texified} = {replaced} = {self.value} $$"
+        else:
+            return f"$$ {name} = {texified} = {self.value} $$"
+
+    def _extract(self, other) -> float:
+        return float(other.value) if isinstance(other, Calculation) else float(other)
+
+    def __add__(self, other):
+        return float(self.value) + self._extract(other)
+
+    def __radd__(self, other):
+        return self._extract(other) + float(self.value)
+
+    def __sub__(self, other):
+        return float(self.value) - self._extract(other)
+
+    def __rsub__(self, other):
+        return self._extract(other) - float(self.value)
+
+    def __mul__(self, other):
+        return float(self.value) * self._extract(other)
+
+    def __rmul__(self, other):
+        return self._extract(other) * float(self.value)
+
+    def __truediv__(self, other):
+        return float(self.value) / self._extract(other)
+
+    def __rtruediv__(self, other):
+        return self._extract(other) / float(self.value)
+
+    def __pow__(self, power):
+        return float(self.value) ** self._extract(power)
+
+    def __neg__(self):
+        return -float(self.value)
+        
+    def __abs__(self):
+        return abs(float(self.value))
+
+class Table():
+    def __init__(self, headers: List[str], values: List[List[Any]], caption: str, add_no: bool = False, starting_number: int = 1):
+        self.headers = headers
+        self.values = values
+        self.caption = caption
+        self.add_no = add_no
+        self.starting_number = starting_number
+        self.repr = self.get_representation()
+
+    def __repr__(self):
+        return self.repr
+
+    def get_representation(self):
+        if self.add_no:
+            headers_string = f"|No.|"
+            breaker_line = "|---|"
+        else:
+            headers_string = f"|"
+            breaker_line = "|"
+    
+        for i in self.headers:
+            headers_string += f"{i}|"
+            breaker_line += "-"*len(i)+"|"
+    
+        table_content = ""
+        for i, row in enumerate(self.values):
+            if self.add_no:
+                table_content += f"|{i+self.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;'>{self.caption}</span>"
+        return f"{caption_html} \n {headers_string}\n{breaker_line}\n{table_content}"
+
+    def toDXF(self, filename: str, cell_width: float = 50.0, cell_height: float = 10.0):
+        try:
+            import ezdxf
+        except ImportError:
+            return f"*(Error: ezdxf library is not installed. Cannot generate {filename})*"
+            
+        doc = ezdxf.new('R2010')
+        msp = doc.modelspace()
+        
+        # Construct full grid data
+        rows = [self.headers] + self.values
+        num_rows = len(rows)
+        num_cols = len(self.headers)
+        
+        # Draw horizontal grid lines
+        for i in range(num_rows + 1):
+            y = -i * cell_height
+            msp.add_line((0, y), (num_cols * cell_width, y))
+            
+        # Draw vertical grid lines
+        for j in range(num_cols + 1):
+            x = j * cell_width
+            msp.add_line((x, 0), (x, -num_rows * cell_height))
+            
+        # Draw text centered in each cell
+        for i, row in enumerate(rows):
+            y = -i * cell_height - (cell_height / 2)
+            for j, cell_val in enumerate(row):
+                if j >= num_cols: continue # Safety bounds
+                x = j * cell_width + (cell_width / 2)
+                msp.add_text(
+                    str(cell_val),
+                    dxfattribs={
+                        'height': cell_height * 0.4,
+                    }
+                ).set_placement((x, y), align=ezdxf.enums.TextEntityAlignment.MIDDLE_CENTER)
+                
+        doc.saveas(filename)
+        return f"*[Successfully exported table to {filename}]({filename})*"
+
+class ListType(Enum):
+    ORDERED = 1
+    UNORDERED = 2
+    CHECKLIST = 3
+
+class CList():
+    def __init__(self, items: List[Any], type: ListType):
+        self.items = items
+        self.type = type
+        self.repr = self.get_representation()
+
+    def __repr__(self):
+        return self.repr
+
+    def get_representation(self):
+        if self.type == ListType.ORDERED:
+            return self.get_ordered()
+        elif self.type == ListType.UNORDERED:
+            return self.get_unordered()
+        elif self.type == ListType.CHECKLIST:
+            return self.get_checklist()
+
+    def get_ordered(self):
+        list_string = ""
+        for i, item in enumerate(self.items):
+            list_string += f"{i+1}. {item}\n"
+        return list_string
+    def get_unordered(self):
+        list_string = ""
+        for i in self.items:
+            list_string += f"* {i}\n"
+        return list_string
+    def get_checklist(self):
+        list_string = ""
+        for i in self.items:
+            list_string += f"- [ ] {i}\n"
+        return list_string
+
+# feat:: footnote list
+# class FootnoteList():
+#     def __init__(self, footnotes: List[Footnote]):
+#         self.footnotes = footnotes
+#         self.repr = self.get_adnotations()
+
+#     def __repr__(self):
+#         return self.repr
+    
+#     def append(self, footnote: Footnote|List[Footnote]):
+#         if isinstance(footnote, List):
+#             self.footnotes = self.footnotes + footnote
+#         else:
+#             self.footnotes = self.footnotes.append(footnote)
+#     def get_adnotations(self):
+#         adnots = ""
+#         for fn in self.footnotes:
+#             adnots = adnots + f"{fn.adnotation}\n"
+
+if __name__ == "__main__":
+    # func_w = lambda x_1, y, z: x_1+y+z
+    # func_eq = Calculation(func_w, [1,2,3], True)
+    # print(func_eq.vars)
+
+
+    
+    print(["lol4", "lol5"][-1])

pyact_cli-1.2.0/pyact/__init__.py

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

{pyact_cli-1.0.0 → pyact_cli-1.2.0}/pyact/cli.py

@@ -1,17 +1,32 @@
 import argparse
 import sys
-import os
 import time
+import shutil
+from pathlib import Path
 from .core import map_content, process_content, build_logs, generate_markdown_toc
 
-def is_cache_valid(build_tree, cache_mtime, root_dir=None):
-    if root_dir is not None:
-        global_file = os.path.join(root_dir, "global.py")
-        if os.path.exists(global_file) and os.path.getmtime(global_file) > cache_mtime:
+def _cache_dependencies(root_dir: Path) -> list[Path]:
+    dependencies = [
+        root_dir / "global.py",
+        root_dir / "pamd.conf",
+        root_dir / "style.css",
+    ]
+    helper_dir = Path(__file__).parents[1] / "pamd_helpers"
+    if helper_dir.exists():
+        dependencies.extend(helper_dir.glob("*.py"))
+    return dependencies
+
+
+def is_cache_valid(build_tree, cache_mtime, root_dir=None, dependencies=None):
+    root_dir = Path(root_dir) if root_dir is not None else None
+    if dependencies is None and root_dir is not None:
+        dependencies = _cache_dependencies(root_dir)
+    for dependency in dependencies or []:
+        if dependency.exists() and dependency.stat().st_mtime > cache_mtime:
             return False
 
-    file_path = os.path.join(build_tree.get("path", ""), build_tree.get("name", "") + ".pamd")
-    if os.path.exists(file_path) and os.path.getmtime(file_path) > cache_mtime:
+    file_path = Path(build_tree["source_path"])
+    if file_path.exists() and file_path.stat().st_mtime > cache_mtime:
         return False
     for t in build_tree.get("templates", []):
         if not is_cache_valid(t, cache_mtime):
@@ -55,12 +70,14 @@ def main():
     parser.add_argument("--css", help="Optional CSS file path to style the DOCX")
     parser.add_argument("--conf", help="Optional path to pamd.conf configuration file")
     parser.add_argument("--lint", action="store_true", help="Run the linter on the project to check for unused variables and files")
+    parser.add_argument("--no-cache", action="store_true", help="Rebuild the document without reading the cache")
+    parser.add_argument("--clear-cache", action="store_true", help="Remove the project cache before compiling")
     
     args = parser.parse_args()
     
-    input_path = os.path.abspath(args.input)
-    directory = os.path.dirname(input_path)
-    filename = os.path.basename(input_path)
+    input_path = Path(args.input).resolve()
+    directory = input_path.parent
+    filename = input_path.name
     
     if filename.endswith(".pamd"):
         filename = filename[:-5]
@@ -73,18 +90,26 @@ def main():
     try:
         build_tree = map_content(filename, directory)
         
-        cache_dir = os.path.join(directory, ".pamd-cache")
-        cache_file = os.path.join(cache_dir, f"{filename}.cache.md")
+        cache_dir = directory / ".pamd-cache"
+        cache_file = cache_dir / f"{filename}.cache.md"
         use_cache = False
+
+        if args.clear_cache and cache_dir.exists():
+            shutil.rmtree(cache_dir)
         
-        if os.path.exists(cache_file):
-            cache_mtime = os.path.getmtime(cache_file)
-            if is_cache_valid(build_tree, cache_mtime, directory):
+        if not args.no_cache and cache_file.exists():
+            cache_mtime = cache_file.stat().st_mtime
+            if is_cache_valid(
+                build_tree,
+                cache_mtime,
+                directory,
+                _cache_dependencies(directory),
+            ):
                 use_cache = True
                 
         if use_cache:
             print("pamd-cache: Using cached markdown...")
-            with open(cache_file, "r", encoding="utf-8") as f:
+            with cache_file.open("r", encoding="utf-8") as f:
                 content = f.read()
         else:
             print("pamd-cache: Cache invalid or missing. Rebuilding...")
@@ -96,14 +121,13 @@ def main():
             total_ms = (total_end - total_start) * 1000
             
             # Write cache
-            if not os.path.exists(cache_dir):
-                os.makedirs(cache_dir)
-            with open(cache_file, "w", encoding="utf-8") as f:
+            cache_dir.mkdir(parents=True, exist_ok=True)
+            with cache_file.open("w", encoding="utf-8") as f:
                 f.write(content)
                 
             # Write build log
-            log_file = os.path.join(cache_dir, "build.log")
-            with open(log_file, "w", encoding="utf-8") as f:
+            log_file = cache_dir / "build.log"
+            with log_file.open("w", encoding="utf-8") as f:
                 f.write("PyAct Build Log\n")
                 f.write("================\n\n")
                 f.write("File Execution Times:\n")
@@ -113,7 +137,7 @@ def main():
         
         md_output = generate_markdown_toc(content)
         if args.output:
-            with open(args.output, "w", encoding="utf-8") as f:
+            with Path(args.output).open("w", encoding="utf-8") as f:
                 f.write(md_output)
             print(f"Successfully compiled to {args.output}")
         else:
@@ -127,28 +151,28 @@ def main():
                 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):
+                local_css = directory / "style.css"
+                if local_css.exists():
                     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")
+                    default_css = Path(__file__).parent / "style.css"
                     styles = style_parser(default_css)
                     
             # Load pamd.conf configuration
             conf = {}
             conf_path = None
             if args.conf:
-                conf_path = os.path.abspath(args.conf)
+                conf_path = Path(args.conf).resolve()
             else:
-                local_conf = os.path.join(directory, "pamd.conf")
-                cwd_conf = os.path.join(os.getcwd(), "pamd.conf")
-                if os.path.exists(local_conf):
+                local_conf = directory / "pamd.conf"
+                cwd_conf = Path.cwd() / "pamd.conf"
+                if local_conf.exists():
                     conf_path = local_conf
-                elif os.path.exists(cwd_conf):
+                elif cwd_conf.exists():
                     conf_path = cwd_conf
 
-            if conf_path and os.path.exists(conf_path):
+            if conf_path and conf_path.exists():
                 from .conf_parser import conf_parser
                 conf = conf_parser(conf_path)
                     

{pyact_cli-1.0.0 → pyact_cli-1.2.0}/pyact/core.py

@@ -1,12 +1,65 @@
 import re
 import json
 import time
-import os
 import linecache
+from pathlib import Path
+from typing import Any, Mapping
 
 build_logs = []
 
-def get_directory(path: str) -> list:
+
+def validate_pamd_document(data: Any, file_path: str | Path) -> list[dict]:
+    """Validate the structural contract of a PAMD notebook document."""
+    path = Path(file_path)
+    if not isinstance(data, dict):
+        raise ValueError(f"Invalid PAMD file {path}: the root must be a JSON object.")
+
+    cells = data.get("cells")
+    if not isinstance(cells, list):
+        raise ValueError(f"Invalid PAMD file {path}: 'cells' must be a JSON array.")
+
+    validated_cells = []
+    markdown_count = 0
+    for index, cell in enumerate(cells):
+        if not isinstance(cell, dict):
+            raise ValueError(
+                f"Invalid PAMD file {path}: cell {index} must be a JSON object."
+            )
+
+        cell_type = cell.get("cell_type")
+        if cell_type not in {"code", "markdown"}:
+            raise ValueError(
+                f"Invalid PAMD file {path}: cell {index} has unsupported "
+                f"cell_type {cell_type!r}; expected 'code' or 'markdown'."
+            )
+
+        source = cell.get("source")
+        if isinstance(source, str):
+            normalized_source = source
+        elif isinstance(source, list) and all(isinstance(line, str) for line in source):
+            normalized_source = "".join(source)
+        else:
+            raise ValueError(
+                f"Invalid PAMD file {path}: cell {index} 'source' must be "
+                "a string or an array of strings."
+            )
+
+        if cell_type == "markdown":
+            markdown_count += 1
+        validated_cells.append(
+            {"cell_type": cell_type, "source": normalized_source}
+        )
+
+    if markdown_count != 1:
+        raise ValueError(
+            f"Invalid PAMD file {path}: expected exactly one markdown cell, "
+            f"found {markdown_count}."
+        )
+
+    return validated_cells
+
+
+def get_directory(path: str | Path) -> list:
     """
     Splits a full file path into its directory component and its filename component.
     
@@ -21,8 +74,8 @@ def get_directory(path: str) -> list:
     Outputs:
         list: A two-element list `[directory_path, filename]`.
     """
-    head, sep, tail = path.rpartition('/')
-    return [head + sep, tail]
+    path = Path(path)
+    return [path.parent, path.name]
 
 def read_pamd_cells(file_path: str):
     """
@@ -39,26 +92,39 @@ def read_pamd_cells(file_path: str):
     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)
+    path = Path(file_path)
+    try:
+        with path.open("r", encoding="utf-8") as f:
+            data = json.load(f)
+    except json.JSONDecodeError as error:
+        raise ValueError(
+            f"Invalid PAMD file {path}: malformed JSON at line "
+            f"{error.lineno}, column {error.colno}: {error.msg}."
+        ) from error
+    except OSError as error:
+        raise OSError(f"Could not read PAMD file {path}: {error}") from error
+
+    cells = validate_pamd_document(data, path)
     
     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)
-            
+    for cell in cells:
+        cell_type = cell["cell_type"]
+        source = cell["source"]
+
         if cell_type == "code":
-            code_content += source + "\n"
+            code_content += source
+            if source and not source.endswith("\n"):
+                code_content += "\n"
         elif cell_type == "markdown":
-            markdown_content += source + "\n"
+            markdown_content += source
+            if source and not source.endswith("\n"):
+                markdown_content += "\n"
             
     return code_content, markdown_content
 
-def get_imports(file: str, code_text: str):
+def get_imports(file: str | Path, code_text: str):
     """
     Executes the Python code from a .pamd file and retrieves the context variables.
     
@@ -75,7 +141,7 @@ def get_imports(file: str, code_text: str):
     Outputs:
         dict: The dictionary of variables returned by the user's `context()` function.
     """
-    filename = f"{file}.pamd"
+    filename = str(Path(file).with_suffix(".pamd"))
     file_namespace = {"__file__": filename}
     if not code_text.strip():
         raise ValueError(f"The file {filename} needs a 'context()' function but has no code cell.")
@@ -108,20 +174,20 @@ def get_imports(file: str, code_text: str):
 
     return result_dict
 
-def get_globals(directory: str):
+def get_globals(directory: str | Path):
     """
     Reads global.py and executes its global_context() function to get global variables.
     """
-    global_path = os.path.join(directory, "global.py")
-    if not os.path.exists(global_path):
+    global_path = Path(directory) / "global.py"
+    if not global_path.exists():
         return {}
         
-    with open(global_path, "r", encoding="utf-8") as f:
+    with global_path.open("r", encoding="utf-8") as f:
         code_text = f.read()
         
-    file_namespace = {"__file__": global_path}
+    file_namespace = {"__file__": str(global_path)}
     try:
-        compiled_code = compile(code_text, global_path, "exec")
+        compiled_code = compile(code_text, str(global_path), "exec")
         exec(compiled_code, file_namespace)
     except Exception as e:
         raise RuntimeError(f"Error executing global.py: {e}")
@@ -178,7 +244,20 @@ def find_templates(text: str):
     pattern = r"<tmp>(.*?)</tmp>"
     return re.findall(pattern, text)
 
-def map_content(file: str, path: str):
+def _template_path(template: str | Path, directory: str | Path) -> Path:
+    template_path = Path(template)
+    if template_path.suffix != ".pamd":
+        template_path = template_path.with_suffix(".pamd")
+    if not template_path.is_absolute():
+        template_path = Path(directory) / template_path
+    return template_path
+
+
+def map_content(
+    file: str | Path,
+    path: str | Path,
+    _active_paths: tuple[Path, ...] = (),
+):
     """
     Recursively maps the dependency tree of a `.pamd` file.
     
@@ -195,32 +274,42 @@ def map_content(file: str, path: str):
         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")
+    source_path = _template_path(file, path).resolve()
+    if source_path in _active_paths:
+        cycle_start = _active_paths.index(source_path)
+        cycle = (*_active_paths[cycle_start:], source_path)
+        cycle_display = " -> ".join(str(item) for item in cycle)
+        raise ValueError(f"Recursive <tmp> template cycle detected: {cycle_display}")
+
+    code_text, main_file = read_pamd_cells(str(source_path))
     templates = find_templates(main_file)
     imports = find_imports(main_file)
     globals_req = find_globals(main_file)
-    meta = get_directory(full_path)
+    meta = get_directory(source_path.with_suffix(""))
     
     ready_t = []
     for i in templates:
-        ready_t.append(map_content(i, meta[0]))
+        ready_t.append(map_content(i, meta[0], (*_active_paths, source_path)))
 
     return {
-        "tag_name": file,
-        "name": meta[1],
+        "tag_name": str(file),
+        "name": str(meta[1]),
         "path": meta[0],
+        "source_path": source_path,
         "imports": imports,
         "globals": globals_req,
         "templates": ready_t
     }
 
+def _resolve_value(values: Mapping[str, Any], key: str) -> Any:
+    current: Any = values
+    for part in key.split("."):
+        if not isinstance(current, Mapping) or part not in current:
+            raise KeyError(key)
+        current = current[part]
+    return current
+
+
 def process_content(build_tree: dict, globals_dict: dict = None):
     """
     Compiles a mapped build tree into a final flat Markdown string.
@@ -230,21 +319,38 @@ def process_content(build_tree: dict, globals_dict: dict = None):
     if globals_dict is None:
         globals_dict = get_globals(build_tree.get("path", ""))
         
-    file_path_base = build_tree.get("path", "") + build_tree.get("name", "")
-    code_text, file_text = read_pamd_cells(file_path_base + ".pamd")
+    source_path = build_tree.get("source_path")
+    if source_path is None:
+        source_path = _template_path(
+            build_tree.get("name", ""),
+            build_tree.get("path", ""),
+        )
+    source_path = Path(source_path)
+    code_text, file_text = read_pamd_cells(str(source_path))
     
     needed_imports = build_tree.get("imports", [])
     if needed_imports:
-        imports = get_imports(file_path_base, code_text)
+        imports = get_imports(source_path, code_text)
         for i in needed_imports:
-            file_text = file_text.replace(f"<ctx>{i}</ctx>", str(imports.get(i, '')))
+            try:
+                value = _resolve_value(imports, i)
+            except KeyError:
+                raise ValueError(
+                    f"Context variable '{i}' requested in {source_path.name} "
+                    "but not returned by context()."
+                ) from None
+            file_text = file_text.replace(f"<ctx>{i}</ctx>", str(value))
             
     needed_globals = build_tree.get("globals", [])
     for g in needed_globals:
-        if g in globals_dict:
-            file_text = file_text.replace(f"<glb>{g}</glb>", str(globals_dict[g]))
-        else:
-            raise ValueError(f"Global variable '{g}' requested via <glb> but not found in global.py's global_context().")
+        try:
+            value = _resolve_value(globals_dict, g)
+        except KeyError:
+            raise ValueError(
+                f"Global variable '{g}' requested via <glb> but not found "
+                "in global.py's global_context()."
+            ) from None
+        file_text = file_text.replace(f"<glb>{g}</glb>", str(value))
 
     for i in build_tree.get("templates", []):
         file_text = file_text.replace(f"<tmp>{i.get('tag_name')}</tmp>", process_content(i, globals_dict))
@@ -253,7 +359,7 @@ def process_content(build_tree: dict, globals_dict: dict = None):
     elapsed_ms = (end_time - start_time) * 1000
     
     build_logs.append({
-        "file": f"{build_tree.get('name', '')}.pamd",
+        "file": source_path.name,
         "time_ms": elapsed_ms
     })
         

{pyact_cli-1.0.0 → pyact_cli-1.2.0}/pyact_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyact-cli
-Version: 1.0.0
+Version: 1.2.0
 Summary: A CLI tool to compile .pamd files to Markdown.
 Home-page: https://github.com/Abstergo2003/PyAct
 Author: Abstergo2003
@@ -37,7 +37,8 @@ pip install pyact-cli
 
 ## 📖 How it works
 
-A `.pamd` file is split into a **Python cell** and a **Markdown cell**. 
+A `.pamd` file contains exactly one **Markdown cell** and may contain multiple
+**Python cells**. Python cells are concatenated in order before execution.
 
 ### 1. Write your Python logic
 Define a `context()` function that returns the variables you want to inject. You can even use the built-in `pamd_helpers` to do heavy lifting!
@@ -86,6 +87,14 @@ Run the compiler from your terminal to generate your final Markdown document:
 pyact path/to/your_file.pamd -o output.md
 ```
 
+Use `--no-cache` to force a rebuild without reading cached Markdown, or
+`--clear-cache` to remove the project's `.pamd-cache` directory before building:
+
+```bash
+pyact path/to/your_file.pamd --no-cache
+pyact path/to/your_file.pamd --clear-cache
+```
+
 ### 5. Compile to Word (DOCX)
 You can also compile straight to a native Microsoft Word Document, complete with CSS styling! 
 ```bash

{pyact_cli-1.0.0 → pyact_cli-1.2.0}/setup.py

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

pyact_cli-1.0.0/pyact/__init__.py

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