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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyact-cli
-Version: 0.5.0
+Version: 0.6.0
 Summary: A CLI tool to compile .pamd files to Markdown.
 Home-page: https://github.com/Abstergo2003/PyAct
 Author: Abstergo2003
@@ -10,11 +10,14 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
+Requires-Dist: python-docx
+Requires-Dist: ezdxf
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 

{pyact_cli-0.5.0 → pyact_cli-0.6.0}/pamd_helpers/__init__.py

@@ -182,4 +182,62 @@ class Footnote:
         """
         Outputs (str): The short inline reference marker to place in the paragraph text.
         """
-        return f"[^{self.number}]\n"
+        return f"[^{self.number}]\n"
+
+def table_to_dxf(headers: List[str], values: List[List[Any]], filename: str, cell_width: float = 50.0, cell_height: float = 10.0) -> str:
+    """
+    Exports a table (headers + values) to a 2D CAD DXF file.
+    
+    Why it is needed:
+    Engineers and designers often need to embed tabulated data (e.g. Bill of Materials, 
+    coordinate tables, parts lists) directly into AutoCAD drawings. This helper converts 
+    a Python table directly into DXF geometry (lines and text) that can be opened in any CAD software.
+    
+    Inputs:
+        headers (List[str]): List of column header names.
+        values (List[List[Any]]): A 2D list containing the row data.
+        filename (str): The output filename (e.g., 'table.dxf').
+        cell_width (float): The width of each cell in drawing units.
+        cell_height (float): The height of each cell in drawing units.
+        
+    Outputs:
+        str: A string confirming the export, formatted as a Markdown link.
+    """
+    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 = [headers] + values
+    num_rows = len(rows)
+    num_cols = len(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})*"

pyact_cli-0.6.0/pamd_helpers/conversions.py

@@ -0,0 +1,126 @@
+"""
+Engineering Unit Conversions for PyAct
+
+A collection of helper functions to seamlessly convert values between 
+Metric (SI) and Imperial / US Customary systems.
+"""
+
+# ==========================================
+# LENGTH CONVERSIONS
+# ==========================================
+
+def mm_to_inch(mm: float) -> float:
+    """Converts millimeters [mm] to inches [in]"""
+    return mm / 25.4
+
+def inch_to_mm(inch: float) -> float:
+    """Converts inches [in] to millimeters [mm]"""
+    return inch * 25.4
+
+def m_to_ft(m: float) -> float:
+    """Converts meters [m] to feet [ft]"""
+    return m * 3.280839895
+
+def ft_to_m(ft: float) -> float:
+    """Converts feet [ft] to meters [m]"""
+    return ft / 3.280839895
+
+# ==========================================
+# AREA & VOLUME CONVERSIONS
+# ==========================================
+
+def mm2_to_in2(mm2: float) -> float:
+    """Converts square millimeters [mm^2] to square inches [in^2]"""
+    return mm2 / 645.16
+
+def in2_to_mm2(in2: float) -> float:
+    """Converts square inches [in^2] to square millimeters [mm^2]"""
+    return in2 * 645.16
+
+def m3_to_ft3(m3: float) -> float:
+    """Converts cubic meters [m^3] to cubic feet [ft^3]"""
+    return m3 * 35.3146667
+
+def ft3_to_m3(ft3: float) -> float:
+    """Converts cubic feet [ft^3] to cubic meters [m^3]"""
+    return ft3 / 35.3146667
+
+# ==========================================
+# MASS & FORCE CONVERSIONS
+# ==========================================
+
+def kg_to_lbs(kg: float) -> float:
+    """Converts kilograms [kg] to pounds-mass [lbs]"""
+    return kg * 2.20462262
+
+def lbs_to_kg(lbs: float) -> float:
+    """Converts pounds-mass [lbs] to kilograms [kg]"""
+    return lbs / 2.20462262
+
+def kn_to_kips(kn: float) -> float:
+    """Converts kilonewtons [kN] to kilopounds-force [kips]"""
+    return kn * 0.224808943
+
+def kips_to_kn(kips: float) -> float:
+    """Converts kilopounds-force [kips] to kilonewtons [kN]"""
+    return kips / 0.224808943
+
+def n_to_lbf(n: float) -> float:
+    """Converts newtons [N] to pounds-force [lbf]"""
+    return n * 0.224808943
+
+def lbf_to_n(lbf: float) -> float:
+    """Converts pounds-force [lbf] to newtons [N]"""
+    return lbf / 0.224808943
+
+# ==========================================
+# PRESSURE & STRESS CONVERSIONS
+# ==========================================
+
+def mpa_to_psi(mpa: float) -> float:
+    """Converts Megapascals [MPa] (or N/mm^2) to pounds per square inch [psi]"""
+    return mpa * 145.037738
+
+def psi_to_mpa(psi: float) -> float:
+    """Converts pounds per square inch [psi] to Megapascals [MPa]"""
+    return psi / 145.037738
+
+def mpa_to_ksi(mpa: float) -> float:
+    """Converts Megapascals [MPa] to kilopounds per square inch [ksi]"""
+    return mpa * 0.145037738
+
+def ksi_to_mpa(ksi: float) -> float:
+    """Converts kilopounds per square inch [ksi] to Megapascals [MPa]"""
+    return ksi / 0.145037738
+
+# ==========================================
+# MOMENT & TORQUE CONVERSIONS
+# ==========================================
+
+def knm_to_kipft(knm: float) -> float:
+    """Converts kilonewton-meters [kNm] to kilopound-feet [kip-ft]"""
+    return knm * 0.737562149
+
+def kipft_to_knm(kipft: float) -> float:
+    """Converts kilopound-feet [kip-ft] to kilonewton-meters [kNm]"""
+    return kipft / 0.737562149
+
+def knm_to_lbfft(knm: float) -> float:
+    """Converts kilonewton-meters [kNm] to pound-force feet [lbf-ft]"""
+    return knm * 737.562149
+
+def lbfft_to_knm(lbfft: float) -> float:
+    """Converts pound-force feet [lbf-ft] to kilonewton-meters [kNm]"""
+    return lbfft / 737.562149
+
+# ==========================================
+# TEMPERATURE CONVERSIONS
+# ==========================================
+
+def c_to_f(celsius: float) -> float:
+    """Converts degrees Celsius [°C] to degrees Fahrenheit [°F]"""
+    return (celsius * 9/5) + 32
+
+def f_to_c(fahrenheit: float) -> float:
+    """Converts degrees Fahrenheit [°F] to degrees Celsius [°C]"""
+    return (fahrenheit - 32) * 5/9

pyact_cli-0.6.0/pamd_helpers/unit.py

@@ -0,0 +1,43 @@
+class Unit:
+    def __init__(self, value: float, unit: str):
+        self.value: float = value
+        self.unit: str = unit
+
+    def __repr__(self) -> str:
+        return f"{self.value} {self.unit}"
+        
+    def _extract(self, other) -> float:
+        return float(other.value) if isinstance(other, Unit) 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))

pyact_cli-0.6.0/pyact/__init__.py

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

{pyact_cli-0.5.0 → pyact_cli-0.6.0}/pyact/cli.py

@@ -1,75 +1,113 @@
-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()
+import argparse
+import sys
+import os
+from .core import map_content, process_content
+
+def is_cache_valid(build_tree, cache_mtime):
+    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:
+        return False
+    for t in build_tree.get("templates", []):
+        if not is_cache_valid(t, cache_mtime):
+            return False
+    return True
+
+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.
+        --lint (bool): Run the linter to check for unused files and variables.
+        
+    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")
+    parser.add_argument("--lint", action="store_true", help="Run the linter on the project to check for unused variables and files")
+    
+    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]
+        
+    if args.lint:
+        from .linter import run_linter
+        run_linter(filename, directory)
+        return
+        
+    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")
+        use_cache = False
+        
+        if os.path.exists(cache_file):
+            cache_mtime = os.path.getmtime(cache_file)
+            if is_cache_valid(build_tree, cache_mtime):
+                use_cache = True
+                
+        if use_cache:
+            print("pamd-cache: Using cached markdown...")
+            with open(cache_file, "r", encoding="utf-8") as f:
+                content = f.read()
+        else:
+            print("pamd-cache: Cache invalid or missing. Rebuilding...")
+            content = process_content(build_tree)
+            # Write cache
+            if not os.path.exists(cache_dir):
+                os.makedirs(cache_dir)
+            with open(cache_file, "w", encoding="utf-8") as f:
+                f.write(content)
+        
+        if args.output:
+            with open(args.output, "w", encoding="utf-8") as f:
+                f.write(content)
+            print(f"Successfully compiled to {args.output}")
+        else:
+            if not args.docx:
+                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.6.0/pyact/linter.py

@@ -0,0 +1,85 @@
+import os
+from .core import read_pamd_cells, get_imports, find_imports, map_content
+
+def run_linter(main_filename: str, directory: str):
+    """
+    Runs the linter on a PyAct project.
+    
+    Checks for:
+    1. Unused .pamd files in the directory.
+    2. Context keys exported but not used in the markdown.
+    3. Context tags requested in the markdown but missing from the context dictionary.
+    """
+    print(f"--- PyAct Linter ---")
+    print(f"Analyzing project starting from: {main_filename}.pamd\n")
+    
+    try:
+        build_tree = map_content(main_filename, directory)
+    except Exception as e:
+        print(f"Error mapping project: {e}")
+        return
+        
+    used_files = set()
+    
+    def collect_used_files(tree):
+        file_path = os.path.join(tree['path'], tree['name'])
+        used_files.add(os.path.abspath(file_path + ".pamd"))
+        for child in tree.get("templates", []):
+            collect_used_files(child)
+            
+    collect_used_files(build_tree)
+    
+    # Check for unused .pamd files in the base directory
+    all_pamd_files = set()
+    for root, _, files in os.walk(directory):
+        for f in files:
+            if f.endswith(".pamd"):
+                all_pamd_files.add(os.path.abspath(os.path.join(root, f)))
+                
+    unused_files = all_pamd_files - used_files
+    if unused_files:
+        print(f"[WARNING] Unused .pamd files found in project directory:")
+        for uf in unused_files:
+            print(f"   - {os.path.relpath(uf, directory)}")
+    else:
+        print("[OK] No unused .pamd files found.")
+        
+    print("\n--- Context Check ---")
+    
+    # Check context in each used file
+    for used_file in used_files:
+        rel_path = os.path.relpath(used_file, directory)
+        try:
+            code_text, md_text = read_pamd_cells(used_file)
+        except Exception:
+            continue
+            
+        try:
+            # Need to pass base name for error reporting in core.py
+            base_name = os.path.splitext(os.path.basename(used_file))[0]
+            context_dict = get_imports(base_name, code_text)
+            exported_keys = set(context_dict.keys())
+        except Exception:
+            # If a file has no code cell or no context(), it returns an empty dict effectively, 
+            # or throws ValueError in get_imports. Let's just treat as empty if error.
+            exported_keys = set()
+            
+        requested_keys = set(find_imports(md_text))
+        
+        unused_exports = exported_keys - requested_keys
+        missing_exports = requested_keys - exported_keys
+        
+        if unused_exports or missing_exports:
+            print(f"\nFile: {rel_path}")
+            if unused_exports:
+                print(f"  [WARNING] Unused context exports (defined in python, not used in markdown):")
+                for k in unused_exports:
+                    print(f"     - {k}")
+            if missing_exports:
+                print(f"  [ERROR] Missing context exports (used in markdown, missing in python):")
+                for k in missing_exports:
+                    print(f"     - {k}")
+        else:
+            pass
+
+    print("\nLinting complete!")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyact-cli
-Version: 0.5.0
+Version: 0.6.0
 Summary: A CLI tool to compile .pamd files to Markdown.
 Home-page: https://github.com/Abstergo2003/PyAct
 Author: Abstergo2003
@@ -10,11 +10,14 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
+Requires-Dist: python-docx
+Requires-Dist: ezdxf
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 

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

@@ -1,14 +1,18 @@
 README.md
 setup.py
 pamd_helpers/__init__.py
+pamd_helpers/conversions.py
+pamd_helpers/unit.py
 pyact/__init__.py
 pyact/cli.py
 pyact/core.py
 pyact/css2json.py
+pyact/linter.py
 pyact/mdTOword.py
 pyact/py2tex.py
 pyact_cli.egg-info/PKG-INFO
 pyact_cli.egg-info/SOURCES.txt
 pyact_cli.egg-info/dependency_links.txt
 pyact_cli.egg-info/entry_points.txt
+pyact_cli.egg-info/requires.txt
 pyact_cli.egg-info/top_level.txt

pyact_cli-0.6.0/pyact_cli.egg-info/requires.txt

@@ -0,0 +1,2 @@
+python-docx
+ezdxf

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

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="pyact-cli",
-    version="0.5.0",
+    version="0.6.0",
     author="Abstergo2003",
     author_email="",
     description="A CLI tool to compile .pamd files to Markdown.",
@@ -19,6 +19,10 @@ setup(
         "Operating System :: OS Independent",
     ],
     python_requires=">=3.8",
+    install_requires=[
+        "python-docx",
+        "ezdxf"
+    ],
     entry_points={
         "console_scripts": [
             "pyact=pyact.cli:main",

pyact_cli-0.5.0/pyact/__init__.py

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