pyact-cli 0.1.0__py3-none-any.whl

pyact/__init__.py

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

pyact/cli.py

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

pyact/core.py

@@ -0,0 +1,103 @@
+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

pyact/helpers.py

@@ -0,0 +1,76 @@
+import inspect
+from .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/py2tex.py

@@ -0,0 +1,155 @@
+import ast
+
+class LatexVisitor(ast.NodeVisitor):
+
+    def prec(self, n):
+        return getattr(self, 'prec_'+n.__class__.__name__, getattr(self, 'generic_prec'))(n)
+
+    def visit_Call(self, n):
+        func = self.visit(n.func)
+        args = ', '.join(map(self.visit, n.args))
+        if func == 'sqrt':
+            return r'\sqrt{%s}' % args
+        else:
+            return r'\operatorname{%s}\left(%s\right)' % (func, args)
+
+    def prec_Call(self, n):
+        return 1000
+
+    def visit_Name(self, n):
+        return n.id
+
+    def prec_Name(self, n):
+        return 1000
+
+    def visit_UnaryOp(self, n):
+        if self.prec(n.op) > self.prec(n.operand):
+            return r'%s \left(%s\right)' % (self.visit(n.op), self.visit(n.operand))
+        else:
+            return r'%s %s' % (self.visit(n.op), self.visit(n.operand))
+
+    def prec_UnaryOp(self, n):
+        return self.prec(n.op)
+
+    def visit_BinOp(self, n):
+        if self.prec(n.op) > self.prec(n.left):
+            left = r'\left(%s\right)' % self.visit(n.left)
+        else:
+            left = self.visit(n.left)
+        if self.prec(n.op) > self.prec(n.right):
+            right = r'\left(%s\right)' % self.visit(n.right)
+        else:
+            right = self.visit(n.right)
+        if isinstance(n.op, ast.Div):
+            return r'\frac{%s}{%s}' % (self.visit(n.left), self.visit(n.right))
+        elif isinstance(n.op, ast.FloorDiv):
+            return r'\left\lfloor\frac{%s}{%s}\right\rfloor' % (self.visit(n.left), self.visit(n.right))
+        elif isinstance(n.op, ast.Pow):
+            return r'%s^{%s}' % (left, self.visit(n.right))
+        else:
+            return r'%s %s %s' % (left, self.visit(n.op), right)
+
+    def prec_BinOp(self, n):
+        return self.prec(n.op)
+
+    def visit_Sub(self, n):
+        return '-'
+
+    def prec_Sub(self, n):
+        return 300
+
+    def visit_Add(self, n):
+        return '+'
+
+    def prec_Add(self, n):
+        return 300
+
+    def visit_Mult(self, n):
+        return r'\;'
+
+    def prec_Mult(self, n):
+        return 400
+
+    def visit_Mod(self, n):
+        return r'\bmod'
+
+    def prec_Mod(self, n):
+        return 500
+
+    def prec_Pow(self, n):
+        return 700
+
+    def prec_Div(self, n):
+        return 400
+
+    def prec_FloorDiv(self, n):
+        return 400
+
+    def visit_LShift(self, n):
+        return r'\operatorname{shiftLeft}'
+
+    def visit_RShift(self, n):
+        return r'\operatorname{shiftRight}'
+
+    def visit_BitOr(self, n):
+        return r'\operatorname{or}'
+
+    def visit_BitXor(self, n):
+        return r'\operatorname{xor}'
+
+    def visit_BitAnd(self, n):
+        return r'\operatorname{and}'
+
+    def visit_Invert(self, n):
+        return r'\operatorname{invert}'
+
+    def prec_Invert(self, n):
+        return 800
+
+    def visit_Not(self, n):
+        return r'\neg'
+
+    def prec_Not(self, n):
+        return 800
+
+    def visit_UAdd(self, n):
+        return '+'
+
+    def prec_UAdd(self, n):
+        return 800
+
+    def visit_USub(self, n):
+        return '-'
+
+    def prec_USub(self, n):
+        return 800
+
+    def visit_Num(self, n):
+        return str(n.n)
+
+    def prec_Num(self, n):
+        return 1000
+
+    def visit_Constant(self, n):
+        return str(n.value)
+    
+    def prec_Constant(self, n):
+        return 1000
+
+    def generic_visit(self, n):
+        if isinstance(n, ast.AST):
+            return r'' % (n.__class__.__name__, ', '.join(map(self.visit, [getattr(n, f) for f in n._fields])))
+        else:
+            return str(n)
+
+    def generic_prec(self, n):
+        return 0
+
+def py2tex(expr):
+    pt = ast.parse(expr.strip())
+    return LatexVisitor().visit(pt.body[0].value)
+
+if __name__ == "__main__":
+    print(py2tex("x**2"))
+    print(py2tex("x/y"))
+    print(py2tex("sqrt(x) + a*b"))

pyact_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: pyact-cli
+Version: 0.1.0
+Summary: A CLI tool to compile .pamd files to Markdown.
+Home-page: https://github.com/yourusername/pyact
+Author: Your Name
+Author-email: your.email@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+# PyAct CLI
+
+PyAct CLI is a tool designed to process `.pamd` files, which bundle Python logic and Markdown content together, similar to a Jupyter Notebook. This compiler resolves variables and dependencies to generate standard Markdown output.
+
+## Installation
+
+You can install it directly from source (or after uploading to PyPI):
+
+```bash
+pip install pyact-cli
+```
+
+## Usage
+
+Compile a `.pamd` file and output to the terminal:
+```bash
+pyact path/to/your_file.pamd
+```
+
+Compile and save the output to a new Markdown file:
+```bash
+pyact path/to/your_file.pamd -o output.md
+```

pyact_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pyact/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+pyact/cli.py,sha256=WmGvWjB7Hhm3aIKFG0oRdwYMM3i19dHf3Uz8kUqRSYQ,1079
+pyact/core.py,sha256=CcUugSmc41KE5AZrP4fUSF8Q_QIIaGoaPo5J1Kzu0l0,3218
+pyact/helpers.py,sha256=lSjiDkxVG_Odd_z1MmaGXzUi7twrynkE5kvVAokfdH0,2222
+pyact/py2tex.py,sha256=VmrJ_OJjakGiAcEN2oiLvTuvSgoqtqJHPEicKKWzovw,3769
+pyact_cli-0.1.0.dist-info/METADATA,sha256=HfW0YZjyyltAalJVH6fsmv5OPBgJwusFrgOeUttsfFk,1218
+pyact_cli-0.1.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+pyact_cli-0.1.0.dist-info/entry_points.txt,sha256=hmmmLfom4oe4moDZ3NKZMviD5V4ABXI68CkphezrGZg,41
+pyact_cli-0.1.0.dist-info/top_level.txt,sha256=DBvVl_zibkXqq9Ua5DkYyW18Tjsedff1nhWa3OoA04c,6
+pyact_cli-0.1.0.dist-info/RECORD,,

pyact_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyact_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyact = pyact.cli:main

pyact_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyact