pyrecli 0.1.2__tar.gz → 0.2.0__tar.gz

{pyrecli-0.1.2 → pyrecli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyrecli
-Version: 0.1.2
+Version: 0.2.0
 Summary: Command line utilities for DiamondFire templates
 Home-page: https://github.com/Amp63/pyrecli
 License: MIT

{pyrecli-0.1.2 → pyrecli-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pyrecli"
-version = "0.1.2"
+version = "0.2.0"
 description = "Command line utilities for DiamondFire templates"
 authors = ["Amp"]
 readme = "README.md"

{pyrecli-0.1.2 → pyrecli-0.2.0}/pyrecli/command/docs.py

@@ -1,8 +1,8 @@
 from typing import Literal, TypedDict
-from result import Result, Ok, Err
+from result import Result, Err
 from dfpyre import DFTemplate, Item, Parameter
 from mcitemlib.itemlib import MCItemlibException
-from pyrecli.util import parse_templates_from_file
+from pyrecli.util import read_input_file, write_output_file, parse_templates_from_string
 
 
 STARTER_BLOCK_LOOKUP = {
@@ -25,7 +25,11 @@ class TemplateDocData(TypedDict):
 
 
 def docs_command(input_path: str, output_path: str, title: str, include_hidden: bool, omit_toc: bool) -> Result[None, str]:
-    templates_result = parse_templates_from_file(input_path)
+    input_result = read_input_file(input_path)
+    if input_result.is_err():
+        return Err(input_result.err_value)
+
+    templates_result = parse_templates_from_string(input_result.ok_value)
     if templates_result.is_err():
         return Err(templates_result.err_value)
     templates = templates_result.ok_value
@@ -68,7 +72,10 @@ def docs_command(input_path: str, output_path: str, title: str, include_hidden:
                     lore_text = [escape_md(l.to_string()) for l in first_arg.get_lore()]
                     if lore_text:
                         template_doc_lines.extend(lore_text)
-                except MCItemlibException:
+                except (MCItemlibException, AttributeError):
+                    # There are so many things that can go wrong here due to various legacy
+                    # item formats and weird MC string edge cases, so we can just skip
+                    # if there's a problem.
                     pass
             
         # Parse parameters
@@ -108,13 +115,10 @@ def docs_command(input_path: str, output_path: str, title: str, include_hidden:
         add_toc_group(process_templates, 'Processes')
         output_lines.append('\n')
 
-
     # Add template docs to output lines
     for doc_data in template_docs:
         output_lines.extend(doc_data['doc_lines'])
         output_lines.append('')
     
-    with open(output_path, 'w') as f:
-        f.write('\n'.join(output_lines))
-    
-    return Ok(None)
+    write_result = write_output_file(output_path, '\n'.join(output_lines))
+    return write_result

{pyrecli-0.1.2 → pyrecli-0.2.0}/pyrecli/command/grabinv.py

@@ -2,7 +2,7 @@ import json
 from result import Result, Ok, Err
 import amulet_nbt
 from amulet_nbt import CompoundTag, StringTag
-from pyrecli.util import connect_to_codeclient
+from pyrecli.util import write_output_file, connect_to_codeclient
 
 
 def grabinv_command(output_path: str) -> Result[None, str]:
@@ -42,8 +42,8 @@ def grabinv_command(output_path: str) -> Result[None, str]:
     if not template_codes:
         return Err('Could not find any templates in the inventory.')
 
-    with open(output_path, 'w') as f:
-        f.write('\n'.join(template_codes))
+    output_result = write_output_file(output_path, '\n'.join(template_codes))
+    if output_result.is_err():
+        return output_result
     
-    print(f'Saved {len(template_codes)} template{"s" if len(template_codes) != 1 else ''} to "{output_path}".')
     return Ok(None)

{pyrecli-0.1.2 → pyrecli-0.2.0}/pyrecli/command/rename.py

@@ -1,8 +1,8 @@
 from typing import Literal
 import re
-from result import Result, Ok, Err
+from result import Result, Err
 from dfpyre import Variable, Number, String, Text
-from pyrecli.util import parse_templates_from_file
+from pyrecli.util import read_input_file, write_output_file, parse_templates_from_string
 
 
 TEXT_CODE_PATTERNS = [
@@ -22,8 +22,13 @@ def rename_var_in_text_code(s: str, var_to_rename: str, new_var_name: str):
 
 def rename_command(input_path: str, output_path: str|None,
                    var_to_rename: str, new_var_name: str,
-                   renamed_var_scope: Literal['game', 'saved', 'local', 'line']|None) -> Result[None, str]:
-    templates_result = parse_templates_from_file(input_path)
+                   var_to_rename_scope: Literal['game', 'saved', 'local', 'line']|None) -> Result[None, str]:
+    
+    input_result = read_input_file(input_path)
+    if input_result.is_err():
+        return Err(input_result.err_value)
+
+    templates_result = parse_templates_from_string(input_result.ok_value)
     if templates_result.is_err():
         return Err(templates_result.err_value)
     templates = templates_result.ok_value
@@ -32,11 +37,8 @@ def rename_command(input_path: str, output_path: str|None,
         for codeblock in template.codeblocks:
             for argument in codeblock.args:
                 if isinstance(argument, Variable):
-                    if argument.name == var_to_rename:
-                        if renamed_var_scope is None:
-                            argument.name = new_var_name
-                        elif argument.scope != renamed_var_scope:
-                            argument.name = new_var_name
+                    if argument.name == var_to_rename and (var_to_rename_scope is None or argument.scope == var_to_rename_scope):
+                        argument.name = new_var_name
                     argument.name = rename_var_in_text_code(argument.name, var_to_rename, new_var_name)
                 
                 elif isinstance(argument, (Number, String, Text)) and isinstance(argument.value, str):
@@ -48,7 +50,5 @@ def rename_command(input_path: str, output_path: str|None,
     
     new_file_content = '\n'.join(t.build() for t in templates)
     write_path = output_path if output_path else input_path
-    with open(write_path, 'w') as f:
-        f.write(new_file_content)
-    
-    return Ok(None)
+    write_result = write_output_file(write_path, new_file_content)
+    return write_result 

pyrecli-0.2.0/pyrecli/command/scan.py

@@ -0,0 +1,19 @@
+from result import Result, Err
+from pyrecli.util import write_output_file, connect_to_codeclient
+
+
+def scan_command(output_path: str) -> Result[None, str]:
+    ws_result = connect_to_codeclient('read_plot')
+    if ws_result.is_err():
+        return Err(ws_result.err_value)
+    ws = ws_result.ok_value
+
+    print('Scanning plot...')
+    ws.send('scan')
+
+    scan_results = ws.recv()
+    print('Done.')
+    ws.close()
+
+    write_result = write_output_file(output_path, scan_results)
+    return write_result

{pyrecli-0.1.2 → pyrecli-0.2.0}/pyrecli/command/script.py

@@ -1,21 +1,26 @@
 import os
 from result import Result, Ok, Err
 from dfpyre import DFTemplate
-from pyrecli.util import parse_templates_from_file
+from pyrecli.util import read_input_file, write_output_file, parse_templates_from_string
 
 
-def write_to_directory(dir_name: str, templates: list[DFTemplate], flags: dict[str, int|bool]):
+def write_to_directory(dir_name: str, templates: list[DFTemplate], flags: dict[str, int|bool]) -> Result[None, str]:
     if not os.path.isdir(dir_name):
         os.mkdir(dir_name)
     
     for template in templates:
         script_path = f'{dir_name}/{template._get_template_name()}.py'
         script_string = template.generate_script(**flags)
-        with open(script_path, 'w') as f:
-            f.write(script_string)
+        try:
+            with open(script_path, 'w') as f:
+                f.write(script_string)
+        except OSError as e:
+            return Err(str(e))
+    
+    return Ok(None)
 
 
-def write_to_single_file(file_path: str, templates: list[DFTemplate], flags: dict[str, int|bool]):
+def write_to_single_file(file_path: str, templates: list[DFTemplate], flags: dict[str, int|bool]) -> Result[None, str]:
     file_content = []
     for i, template in enumerate(templates):
         if i == 0:
@@ -23,20 +28,21 @@ def write_to_single_file(file_path: str, templates: list[DFTemplate], flags: dic
         else:
             template_script = template.generate_script(include_import=False, assign_variable=True, **flags)
         file_content.append(template_script)
-
-    with open(file_path, 'w') as f:
-        f.write('\n\n'.join(file_content))
+    
+    return write_output_file(file_path, '\n\n'.join(file_content))
 
 
 def script_command(input_path: str, output_path: str, one_file: bool, flags: dict[str, int|bool]) -> Result[None, str]:
-    templates_result = parse_templates_from_file(input_path)
+    input_result = read_input_file(input_path)
+    if input_result.is_err():
+        return Err(input_result.err_value)
+
+    templates_result = parse_templates_from_string(input_result.ok_value)
     if templates_result.is_err():
         return Err(templates_result.err_value)
     templates = templates_result.ok_value
     
-    if one_file:
-        write_to_single_file(output_path, templates, flags)
-    else:
-        write_to_directory(output_path, templates, flags)
-
-    return Ok(None)
+    if one_file or output_path == '-':
+        return write_to_single_file(output_path, templates, flags)
+    
+    return write_to_directory(output_path, templates, flags)

{pyrecli-0.1.2 → pyrecli-0.2.0}/pyrecli/command/send.py

@@ -1,9 +1,13 @@
 from result import Result, Ok, Err
-from pyrecli.util import connect_to_codeclient, parse_templates_from_file
+from pyrecli.util import connect_to_codeclient, read_input_file, parse_templates_from_string
 
 
 def send_command(input_path: str) -> Result[None, str]:
-    templates_result = parse_templates_from_file(input_path)
+    input_result = read_input_file(input_path)
+    if input_result.is_err():
+        return Err(input_result.err_value)
+
+    templates_result = parse_templates_from_string(input_result.ok_value)
     if templates_result.is_err():
         return Err(templates_result.err_value)
     templates = templates_result.ok_value

pyrecli-0.2.0/pyrecli/command/slice.py

@@ -0,0 +1,21 @@
+from result import Result, Err
+from pyrecli.util import read_input_file, write_output_file, parse_templates_from_string
+
+def slice_command(input_path: str, output_path: str, target_length: int) -> Result[None, str]:
+    input_result = read_input_file(input_path)
+    if input_result.is_err():
+        return Err(input_result.err_value)
+
+    templates_result = parse_templates_from_string(input_result.ok_value)
+    if templates_result.is_err():
+        return Err(templates_result.err_value)
+    templates = templates_result.ok_value
+
+    if not templates:
+        return Err(f'Could not find any templates in {input_path}')
+    
+    first_template = templates[0]
+    sliced_templates = first_template.slice(target_length)
+    built_templates = [t.build() for t in sliced_templates]
+
+    return write_output_file(output_path, '\n'.join(built_templates))

{pyrecli-0.1.2 → pyrecli-0.2.0}/pyrecli/pyrecli.py

@@ -8,6 +8,15 @@ from pyrecli.command.script import script_command
 from pyrecli.command.rename import rename_command
 from pyrecli.command.grabinv import grabinv_command
 from pyrecli.command.docs import docs_command
+from pyrecli.command.slice import slice_command
+
+
+def slice_target_length(value):
+    MINIMUM_LENGTH = 5
+    ivalue = int(value)
+    if ivalue < MINIMUM_LENGTH:
+        raise argparse.ArgumentTypeError(f'Target length must be at least {MINIMUM_LENGTH} codeblocks')
+    return ivalue
 
 
 def main():
@@ -36,18 +45,23 @@ def main():
     parser_rename.add_argument('var_to_rename', help='The variable to rename', type=str)
     parser_rename.add_argument('new_var_name', help='The new name for the variable', type=str)
     parser_rename.add_argument('--var_to_rename_scope', '-s', help='The scope to match', type=str, default=None)
-    parser_rename.add_argument('--output_path', '-o', help='The file or directory to output to', type=str, default=None)
+    parser_rename.add_argument('--output_path', '-o', help='The file to output to', type=str, default=None)
 
     parser_grabinv = subparsers.add_parser('grabinv', help='Save all templates in the inventory to a file with CodeClient')
     parser_grabinv.add_argument('output_path', help='The file to output template data to', type=str)
 
     parser_docs = subparsers.add_parser('docs', help='Generate markdown documentation from template data')
     parser_docs.add_argument('input_path', help='The file containing template data', type=str)
-    parser_docs.add_argument('output_path', help='The file or directory to output to', type=str)
+    parser_docs.add_argument('output_path', help='The file to output to', type=str)
     parser_docs.add_argument('title', help='The title for the docs', type=str)
     parser_docs.add_argument('--include_hidden', '-ih', help='Include hidden functions and processes', action='store_true')
     parser_docs.add_argument('--notoc', help='Omit the table of contents', action='store_true')
 
+    parser_slice = subparsers.add_parser('slice', help='Slice a template into multiple smaller templates')
+    parser_slice.add_argument('input_path', help='The file containing template data', type=str)
+    parser_slice.add_argument('output_path', help='The file to output template data to', type=str)
+    parser_slice.add_argument('target_length', help='The maximum length of each sliced template', type=slice_target_length)
+    
     parsed_args = parser.parse_args()
 
     match parsed_args.command:
@@ -81,6 +95,12 @@ def main():
                 parsed_args.input_path, parsed_args.output_path,
                 parsed_args.title, parsed_args.include_hidden, parsed_args.notoc
             )
+        
+        case 'slice':
+            command_result = slice_command(
+                parsed_args.input_path, parsed_args.output_path,
+                parsed_args.target_length
+            )
     
     if command_result.is_err():
         print(command_result.err_value)

{pyrecli-0.1.2 → pyrecli-0.2.0}/pyrecli/util.py

@@ -1,5 +1,6 @@
 import os
 import re
+import sys
 from result import Result, Ok, Err
 import websocket
 from dfpyre import DFTemplate
@@ -31,12 +32,8 @@ def connect_to_codeclient(scopes: str|None=None) -> Result[websocket.WebSocket,
     return Ok(ws)
 
 
-def parse_templates_from_file(path: str) -> Result[list[DFTemplate], str]:
-    if not os.path.isfile(path):
-        return Err(f'"{path}" is not a file.')
-    
-    with open(path, 'r') as f:
-        template_codes = f.read().split('\n')
+def parse_templates_from_string(templates: str) -> Result[list[DFTemplate], str]:
+    template_codes = templates.split('\n')
     
     for i, template_code in enumerate(template_codes):
         if not BASE64_REGEX.match(template_code):
@@ -46,3 +43,34 @@ def parse_templates_from_file(path: str) -> Result[list[DFTemplate], str]:
         return Ok([DFTemplate.from_code(c) for c in template_codes])
     except Exception as e:
         return Err(str(e))
+
+
+def read_input_file(path: str) -> Result[str, str]:
+    if path == '-':
+        try:
+            input_string = sys.stdin.read()
+        except EOFError:
+            pass
+        return Ok(input_string.strip())
+    
+    if not os.path.isfile(path):
+        return Err(f'"{path}" is not a file.')
+    
+    try:
+        with open(path, 'r') as f:
+            return Ok(f.read())
+    except OSError as e:
+        return Err(str(e))
+
+
+def write_output_file(path: str, content: str) -> Result[None, str]:
+    if path == '-':
+        print(content, end='')
+    else:
+        try:
+            with open(path, 'w') as f:
+                f.write(content)
+        except OSError as e:
+            return Err(str(e))
+
+    return Ok(None)

pyrecli-0.1.2/pyrecli/command/scan.py

@@ -1,24 +0,0 @@
-from result import Result, Ok, Err
-from pyrecli.util import connect_to_codeclient
-
-
-def scan_command(output_path: str) -> Result[None, str]:
-    ws_result = connect_to_codeclient('read_plot')
-    if ws_result.is_err():
-        return Err(ws_result.err_value)
-    ws = ws_result.ok_value
-
-    print('Scanning plot...')
-    ws.send('scan')
-
-    scan_results = ws.recv()
-    print('Done.')
-    ws.close()
-
-    with open(output_path, 'w') as f:
-        f.write(scan_results)
-
-    amount_templates = scan_results.count('\n')
-    print(f'Scanned {amount_templates} template{"s" if amount_templates != 1 else ''} successfully.')
-    
-    return Ok(None)