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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyact-cli
-Version: 1.1.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.1.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.1.0 → pyact_cli-1.2.0}/pamd_helpers/__init__.py

@@ -1,8 +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.
@@ -19,12 +57,8 @@ def equation(func: Callable, values: List[Any]) -> str:
         str: A Markdown math string formatted as `$$ Name = Equation = Value $$`.
     """
     print("Function 'equation()' is deprecated and will be removed, please use Calculation() class.")
-    source = inspect.getsource(func)
     value = func(*values)
-    name, sep, tail = source.rpartition("=")
-    print(name, tail)
-    head, sep, equ = tail.rpartition(":")
-    print(head, equ)
+    name, _, equ = _extract_lambda_parts(func)
     
     name = name.strip()
     if "_" in name:
@@ -259,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.
@@ -351,12 +388,7 @@ class Calculation:
             return Calculation(self.func, values, self.replace, precision)
 
     def get_representation(self):
-        source = inspect.getsource(self.func)
-
-        name, sep, tail = source.rpartition("=")
-
-        head, sep, equ = tail.rpartition(":")
-        self.vars = head.replace("lambda", "").replace(" ", "").split(",")
+        name, self.vars, equ = _extract_lambda_parts(self.func)
         
         name = name.strip()
         self.name = f"$ {py2tex(name)} $"
@@ -415,7 +447,7 @@ class Calculation:
 
 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.headers = headers
         self.values = values
         self.caption = caption
         self.add_no = add_no
@@ -528,7 +560,30 @@ class CList():
             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)
+    # 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.1.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.1.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.1.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.1.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.1.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.1.0",
+    version="1.2.0",
     author="Abstergo2003",
     author_email="",
     description="A CLI tool to compile .pamd files to Markdown.",

pyact_cli-1.1.0/pyact/__init__.py

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