rp 0.1.969__tar.gz → 0.1.1106__tar.gz

rp-0.1.1106/.gitignore

@@ -0,0 +1,8 @@
+
+Olde
+Olde
+rp-0.1.848
+rp.egg-info
+rp.egg-info
+dist
+rp.egg-info

rp-0.1.1106/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 1.0
+Name: rp
+Version: 0.1.1106
+Summary: Ryan's Python
+Home-page: https://github.com/RyannDaGreat/Quick-Python
+Author: Ryan Burgert
+Author-email: ryancentralorg@gmail.com
+License: UNKNOWN
+Description: UNKNOWN
+Keywords: not_searchable_yet_go_away_until_later_when_this_is_polished
+Platform: UNKNOWN

rp-0.1.1106/rp/__main__.py

@@ -0,0 +1,15 @@
+import sys
+def main():
+    if len(sys.argv) > 1 and sys.argv[1] == "exec" and len(sys.argv) > 2:
+        # Import everything from your package at the top level
+
+        # Execute the command passed in the arguments
+        import rp
+        rp.exeval('from rp import *\n'+' '.join(sys.argv[2:]))
+    else:
+        # If no additional arguments or not the 'run' command, call _pterm
+        from rp.r import _pterm
+        _pterm()
+
+if __name__ == '__main__':
+    main()

rp-0.1.1106/rp/experimental/__init__.py

@@ -0,0 +1 @@
+from .powerpoint_converter import process_powerpoint_file

rp-0.1.1106/rp/experimental/debug_comment.py

@@ -0,0 +1,159 @@
+import inspect
+import atexit
+import rp
+
+#TODO: Integrate this into RP's repl too somehow
+#      when repl command finishes, we should also trigger it - not just atexit
+#      Also we should be able to do this when using <c-e> -- should modify the buffer (can be undone with <c-z> as normal)
+#      SHould be able to toggle this on and off globally to disable debug_eval's
+#      Should be able to make it verbose or silent
+#      Perhaps ask a yes/no at the end of whether we shoudl replace
+#      Inform the user of what files have changed at least...ONLY IF they changed...
+#      Allow a frames_back or similar option to debug_comment so other functions can build upon it, adding defaults etc.
+
+def is_zero_arg_callable(func):
+    if callable(func):
+        if not inspect.signature(func).parameters:
+            return True
+    return False
+
+# List to store results and metadata
+_debug_comment_results = []
+
+def debug_comment(value):
+    """
+    Modifies the source code of the file this was called in!
+    Best practice is to commit all changed to git before this is called so you can revert changes.
+
+    Notes:
+        Because it simply adds or modifies # comments, the number of lines in a modified file will not be changed by this code
+
+    EXAMPLE:
+        >>> import rp
+
+        >>> #This function modifies your code - it adds comments next to debug_comment that show what it evaluated
+        >>> rp.debug_comment(rp.debug_comment)# --> <function debug_comment at 0x10717cee0>
+
+        >>> #If you align the comments like this it will respect the alignment upon updating
+        >>> rp.debug_comment(rp.debug_comment.__module__)# --> rp.experimental.debug_comment
+        >>> rp.debug_comment(rp)                         # --> <module 'rp' from '/opt/homebrew/lib/python3.10/site-packages/rp/__init__.py'>
+        >>> rp.debug_comment(__file__)                   # --> /Users/ryan/CleanCode/Sandbox/debugevaltest/evaltest.py
+        >>> rp.debug_comment(__name__)                   # --> __main__
+
+        >>> rp.debug_comment("What\nHappens\nWith\nMultiple\nLines")# --> 'What\nHappens\nWith\nMultiple\nLines'
+
+        >>> #The last evaluation will be the one that's kept
+        >>> for i in range(5):
+        >>> rp.debug_comment(i)   # --> 4
+        >>> rp.debug_comment(i**2)# --> 16
+
+        >>> rp.debug_comment(# --> I is 4
+        >>> "I is "+str(i)
+        >>> )   
+
+        >>> #This is what happens if you call it on multiple lines
+        >>> rp.debug_comment(# --> 127
+        >>> 123+i
+        >>> )   
+
+        >>> #If you give it a function that takes 0 args, it will try to evaluate it
+        >>> #This is good for if you want to disable debug_comments and disable all the evaluation inside them too to make your code faster
+        >>> rp.debug_comment(lambda: 22*22)# --> 484
+
+        >>> #Use cases:
+        >>> import torch
+        >>> t=torch.randn(10,100).cpu()
+        >>> rp.debug_comment(t.shape) # --> torch.Size([10, 100])
+        >>> rp.debug_comment(t.dtype) # --> torch.float32
+        >>> rp.debug_comment(t.min()) # --> tensor(-3.1440)
+        >>> rp.debug_comment(t.max()) # --> tensor(2.9910)
+        >>> rp.debug_comment(t.device)# --> cpu
+    """
+    # TODO: allow varargs
+    # Kwargs will be reserved for special purposes, like if we want to also record the date, or number of times the value changed or number of times we called debug comment etc etc
+
+    # Get caller's frame
+    frame = inspect.currentframe().f_back
+    filename = frame.f_globals['__file__']
+    lineno = frame.f_lineno
+    
+    try:
+        if is_zero_arg_callable(value):
+            # If value is a zero-argument callable, call it
+            result = value()
+        ## Disabled eval-strings because I found I often feed it strings...this only makes sense if we give it a string literal, requiring complex introspection and parsing
+        # elif isinstance(value, str):
+        #     # Evaluate the string expression
+        #     result = eval(value, frame.f_globals, frame.f_locals)
+        else:
+            # For non-callable, non-string values, convert directly to string
+            result = value
+
+        try:
+            result = str(result)
+        except Exception as e:
+            result = "Error turning value into string: " + str(e)
+
+    except Exception as e:
+        result = "Error: " + str(e)
+
+    if '\n' in result or '\r' in result: 
+        result=repr(result) #No multiline allowed! Has to fit in a single comment string
+
+    _debug_comment_results.append((filename, lineno, result))
+    
+    #Let original value pass through
+    return value
+
+def format_debug_comment(result):
+    # _debug_print(result) # This can get a bit spammy...
+    return comment_prefix+str(result)
+
+def _debug_print(x):
+    rp.fansi_print('rp.debug_comment: '+str(x), 'green', 'underlined')
+
+comment_prefix = "# --> " #Make this regex-friendly. TODO: regex escape this
+
+def _perform_debug_eval_substitutions():
+    # Process each file only once
+    file_changes = {}
+    for filename, lineno, result in _debug_comment_results:
+        if filename not in file_changes:
+            with open(filename, 'r') as file:
+                file_changes[filename] = file.readlines()
+        
+        # Prepare new comment
+        new_comment = format_debug_comment(result)
+        current_line = file_changes[filename][lineno - 1]
+        
+        #TODO: Do this with split_python_tokens instead and do more checks to make sure the source wasn't modified as it was running so that we're replacing the right line. AKA check to make sure this line in the file matches the line in the linecache, and starts with either rp.debug_comment or debug_comment. And check to make sure we only modify the last --> because --> might be in the value itself (unlikely edge case granted).
+
+        # Check if there's an existing debug comment and replace it
+        if comment_prefix in current_line:
+            current_line = current_line[:current_line.rfind(comment_prefix)] + new_comment + '\n'
+        else:
+            current_line = current_line.rstrip() + new_comment + '\n'
+        
+        file_changes[filename][lineno - 1] = current_line
+
+    # Write changes back to the files
+    for filename, lines in file_changes.items():
+        with open(filename, 'w') as file:
+            try:
+                _debug_print("writing to "+filename)
+                file.writelines(lines)
+            except Exception:
+                _debug_print("Failed to modify "+filename)
+
+    #Don't do anything twice
+    _debug_comment_results.clear()
+
+atexit.register(_perform_debug_eval_substitutions)
+
+# Example usage within the same file
+if __name__ == "__main__":
+    x = 10
+    debug_comment(lambda:'#####'+ str(x * 20))  # This should replace or append the result `20` to this line in the source file. # --> #####200# ----> #####200
+    for _ in range(10):
+        from rp import random_int
+        debug_comment(lambda:"What is "+str(344*random_int(0,100))) # --> What is 11008# ----> What is 24424

rp-0.1.1106/rp/experimental/powerpoint_converter.py

@@ -0,0 +1,126 @@
+"""
+Ryan Burgert, April 2024
+
+This tool is meant to solve a problem: when I have powerpoint files with MP4 files, and I upload them to Google Slides, all the videos are replaced by images! What the fuck?
+Turns out the official way to add videos to Google Slides is to upload each video to Google Drive, then in the Google Slides interface select them for insertion one by one. Very annoying.
+
+This script changes a powerpoint file so that when its uploaded to Google Slides, the MP4 animations are all converted to GIF's!
+Whatsmore - it doesn't destroy *anything* in the original powerpoint file - you can use it as normal!
+
+How does it work?
+Well, those static images google slides replaces your videos with - they're thumnails that can be found in the powerpoint file, that are automatically created when you upload an MP4 to powerpoint.
+Did you know that .pptx files are actually zip files? Yeah! You can unzip them and look inside - you'll find a file structure!
+Usually these thumbnails are png images - but we can replace them with GIF's of the original videos - and these will be animated when viewed in a web browser!
+Note that this causes some 'corruption' to the powerpoint file (no damage that I can see) - but to fix it open the new pptx file this script creates, let powerpoint correct the errors, then re-save it.
+That file can be uploaded to Google Slides and all the animations will work!
+
+To use this code:
+    process_powerpoint_file('/Users/ryan/Desktop/Eyeline_April2_2024.pptx')
+
+"""
+
+from rp import *
+
+__all__=['process_powerpoint_file']
+
+def _get_thumbnail_mapping(index_xml, slide_xml):    
+    #https://chat.openai.com/share/35113188-1527-4309-ae6e-cbb0c4643218
+    import xml.etree.ElementTree as ET
+
+    # Parse the XML data
+    index_root = ET.fromstring(index_xml)
+    slide_root = ET.fromstring(slide_xml)
+
+    # Extract relationship mappings from the index XML
+    relationship_map = {}
+    for relationship in index_root.findall("{http://schemas.openxmlformats.org/package/2006/relationships}Relationship"):
+        r_id = relationship.get("Id")
+        target = relationship.get("Target")
+        relationship_map[r_id] = target.split('/')[-1]  # Extract the file name
+
+    # Now find video to image mappings in the slide XML
+    video_thumbnail_map = {}
+    for pic in slide_root.findall(".//{http://schemas.openxmlformats.org/presentationml/2006/main}pic"):
+        nv_pr = pic.find(".//{http://schemas.openxmlformats.org/presentationml/2006/main}nvPr")
+        if nv_pr is not None and nv_pr.find("{http://schemas.openxmlformats.org/drawingml/2006/main}videoFile") is not None:
+            video_r_id = nv_pr.find("{http://schemas.openxmlformats.org/drawingml/2006/main}videoFile").get("{http://schemas.openxmlformats.org/officeDocument/2006/relationships}link")
+            blip = pic.find(".//{http://schemas.openxmlformats.org/drawingml/2006/main}blip")
+            if blip is not None:
+                image_r_id = blip.get("{http://schemas.openxmlformats.org/officeDocument/2006/relationships}embed")
+                video_file = relationship_map.get(video_r_id, None)
+                image_file = relationship_map.get(image_r_id, None)
+                if video_file and image_file:
+                    video_thumbnail_map[video_file] = image_file
+
+    return video_thumbnail_map
+
+def get_thumbnail_mappings(pptx_root='.'):
+    #Returns something like {'media1.mp4': 'image1.png', 'media2.mp4': 'image2.png', 'media3.mp4': 'image3.png', 'media4.mp4': 'image4.png' ... }
+    slide_xmls=rp.get_all_files(pptx_root,'ppt/slides',file_extension_filter='xml',sort_by='number')
+    rel_xmls=rp.get_all_files(pptx_root,'ppt/slides/_rels',file_extension_filter='rels',sort_by='number')
+    print(pptx_root)
+
+    thumbnail_mappings={}
+    for rel_xml,slide_xml in zip(rel_xmls,slide_xmls):
+        slide_thumbnail_mapping=_get_thumbnail_mapping(
+            text_file_to_string(rel_xml),
+            text_file_to_string(slide_xml),
+        )
+        thumbnail_mappings.update(slide_thumbnail_mapping)
+    return gather_vars('thumbnail_mappings slide_xmls rel_xmls')
+
+def convert_mp4_to_gif(mp4_path,gif_path=None):
+    if path_exists(gif_path):
+        return gif_path#Don't re-do work for no reason
+    pip_import('moviepy')
+    from moviepy.editor import VideoFileClip
+    videoClip = VideoFileClip(mp4_path)
+    gif_path=gif_path or with_file_extension(mp4_path,'gif',replace=True)
+    print(gif_path)
+    videoClip.write_gif(gif_path)
+    return gif_path
+
+def process_powerpoint_file(pptx_path):
+    folder_name = strip_file_extension(pptx_path) + "_extracted"
+    folder_name = get_unique_copy_path(folder_name)
+    folder_path = with_folder_name(pptx_path,folder_name)
+    unzip_to_folder(pptx_path, folder_path, treat_as="zip")
+    assert folder_exists(folder_path)
+    try:
+        thumbnail_mappings, slide_xmls, rel_xmls = destructure(get_thumbnail_mappings(pptx_root=folder_path))
+
+        with SetCurrentDirectoryTemporarily(path_join(folder_path,'ppt','media')):        
+            replacements={}
+            for mp4,thumbnail in thumbnail_mappings.items():
+                fansi_print(mp4+'  –––––  '+thumbnail,'green')
+                gif_path=convert_mp4_to_gif(mp4,with_file_extension(thumbnail,'gif',replace=True))
+                replacements[thumbnail]=gif_path
+                
+        print(replacements)
+
+        for file in slide_xmls+rel_xmls:    
+            file_text=text_file_to_string(file)
+            for before,after in replacements.items():
+                file_text=file_text.replace(before,after)
+            string_to_text_file(file,file_text)
+                
+        new_pptx_path=make_zip_file_from_folder(folder_path)
+        new_pptx_path=rename_file(new_pptx_path,with_file_extension(new_pptx_path,'pptx',replace=True))
+
+        print()
+        print()
+        fansi_print("CONVERSION NEARLY COMPLETE!",'yellow','bold')
+        fansi_print("Please re-save this using powerpoint, which fixes corruption errors caused by this process",'yellow','bold')
+        fansi_print("The file you save in powerpoint can be directly uploaded into Google Slides, with working animations!",'yellow','bold')
+        if input_yes_no('Would you like to open it now?'):
+            open_file_with_default_application(new_pptx_path)
+        
+
+        return new_pptx_path
+    
+    
+    finally:
+        delete_directory(folder_path)
+
+#EXAMPLE:
+#process_powerpoint_file('/Users/ryan/Desktop/Eyeline_April2_2024.pptx')

rp-0.1.1106/rp/libs/draw_code_minimap.py

@@ -0,0 +1,159 @@
+import sys
+
+
+def draw_minimap(hscale: int, vscale: float, padding: int, code:str):
+    assert hscale >= 0, hscale
+    assert vscale >= 0, vscale
+    assert padding >= 0, padding
+
+    # We won't handle auto-importing this, as neither does black need to be...
+    # pip_import("drawille", auto_yes=True)
+
+    import drawille
+
+    # Prevent Giant Outputs
+    MIN_WIDTH = padding
+    MAX_WIDTH = 1000
+    MIN_HEIGHT = 1
+    MAX_HEIGHT = 100000
+
+    # Handle tabs as 4 spaces
+    code = code.replace("\t", "    ")
+
+    # Vertical Scaling
+    lines = code.splitlines()
+    num_lines = len(lines)
+    num_lines = max(MIN_HEIGHT, round(num_lines * vscale))
+    num_lines = min(num_lines, MAX_HEIGHT)
+    lines = resize_list(lines, num_lines)
+
+    # Horizontal Scaling
+    if isinstance(hscale, int):
+        lines = [line * hscale for line in lines]
+    else:
+        assert isinstance(hscale, float)
+        lines = [line[: int(MAX_WIDTH / hscale) + 1] for line in lines]
+        lines = [resize_list(line, round(len(line) * hscale)) for line in lines]
+        lines = ["".join(line) for line in lines]
+    lines = [line[:MAX_WIDTH] for line in lines]
+
+    HEIGHT = len(lines)
+    WIDTH = max(map(len, lines))
+    WIDTH = max(MIN_WIDTH, WIDTH)
+
+    canvas = drawille.Canvas()
+
+    # Set the size
+    canvas.set(0, 0)
+    canvas.set(WIDTH - 1, HEIGHT - 1)
+
+    for y, line in enumerate(lines):
+        for x, char in enumerate(line):
+            if char != " ":
+                canvas.set(x, y)
+
+    output = canvas.frame()
+    output = output.splitlines()
+    output = [x.ljust(MAX_WIDTH) for x in output]
+    output = '\n'.join(output)
+
+    print(output)
+    # print(make_string_rectangular(output).replace(" ", fansi("·", "green")))
+
+
+# INLINED FROM RP FOR FAST LOADING:
+
+
+def resize_list(array: list, length: int):
+    """
+    This function stretches or compresses a list to a given length using nearest-neighbor interpolation.
+    The last element of the input list is always included in the output list, regardless of the target length.
+
+    Parameters:
+        array (list): The input list to resize.
+        length (int): The target length of the list.
+
+    Assumptions:
+        The function assumes that the target length is a non-negative integer.
+
+    Returns:
+        list: The resized list to the target length.
+
+    Examples:
+        >>> resize_list([0,1,2,3,4], 5)
+        [0, 1, 2, 3, 4]
+        # The target length is the length of the input array. No change.
+
+        >>> resize_list([0,1,2,3,4,5,6,7,8,9], 5)
+        [0, 2, 4, 6, 9]
+        # Elements are skipped when resizing to a shorter length, but the last element is always included.
+
+        >>> resize_list([1,2,3,4,5,6,7,8,9], 3)
+        [1, 5, 9]
+
+        >>> resize_list([1,2,3,4,5,6,7,8,9], 5)
+        [1, 3, 5, 7, 9]
+
+        >>> resize_list([0,1,2,3,4], 10)
+        [0, 0, 1, 1, 2, 2, 3, 3, 4, 4]
+        # Elements are duplicated during resizing to a longer length.
+
+        >>> resize_list([0,1,2,3,4], 1)
+        [4]
+        # Even when resizing to length 1, the last element is included.
+
+        >>> resize_list(range(3000000000000000),4)
+        [0, 1000000000000000, 1999999999999999, 2999999999999999]
+        # Pro-tip: this ran in .00001 seconds! You can use it to get indices by passing in a range object
+
+    """
+
+    assert isinstance(
+        length, int
+    ), "Length must be an integer, but got %s instead" % repr(type(length))
+    assert length >= 0, (
+        "Length must be a non-negative integer, but got %i instead" % length
+    )
+
+    if len(array) > 1 and length > 1:
+        step = (len(array) - 1) / (length - 1)
+    else:
+        step = 0  # default step size to 0 if array has only 1 element or target length is 1
+
+    return [array[round(i * step)] for i in range(length)]
+
+
+def text_file_to_string(file_path: str) -> str:
+    "text_file_to_string(file_path) reads text file"
+
+    try:
+        return open(file_path).read()
+    except UnicodeDecodeError:
+        # UnicodeDecodeError: 'ascii' codec can't decode byte 0xc3 in position 4781: ordinal not in range(128)
+        return open(file_path, encoding="latin").read()
+
+
+def usage():
+    print("Usage: %s <hscale> <vscale> <padding> [file]" % sys.argv[0], file=sys.stderr)
+
+
+def main():
+    if len(sys.argv) < 4:
+        usage()
+        sys.exit(1)
+
+    hscale = float(sys.argv[1])
+    vscale = float(sys.argv[2])
+    padding = int(sys.argv[3])
+
+    try:
+        file = sys.argv[4]
+        code = open(file).read()
+    except Exception:
+        code = sys.stdin.read()
+
+    draw_minimap(hscale, vscale, padding, code)
+
+
+if __name__ == "__main__":
+    main()