rp 0.1.1280__tar.gz → 0.1.1282__tar.gz

{rp-0.1.1280 → rp-0.1.1282}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: rp
-Version: 0.1.1280
+Version: 0.1.1282
 Summary: Ryan's Python
 Home-page: https://github.com/RyannDaGreat/Quick-Python
 Author: Ryan Burgert

{rp-0.1.1280 → rp-0.1.1282}/rp/r.py

@@ -16024,7 +16024,7 @@ default_python_input_eventloop = None  # Singleton for python_input
 #     # print_stack_trace(re)
 #     # print("THE DEMON SCREAMS")
 
-def split_into_sublists(l, sublist_len: int, *, strict=False, keep_remainder=True):
+def split_into_sublists(l, sublist_len: int, *, strict=False, keep_remainder=True, lazy=False):
     """
     If strict: sublist_len MUST evenly divide len(l)
     It will return a list of tuples, unless l is a string, in which case it will return a list of strings
@@ -16045,15 +16045,37 @@ def split_into_sublists(l, sublist_len: int, *, strict=False, keep_remainder=Tru
     """
 
     assert is_number(sublist_len),'sublist_len should be an integer, but got type '+repr(type(sublist_len))
-    if strict:
-        assert not len(l)%sublist_len,'len(l)=='+str(len(l))+' and sublist_len=='+str(sublist_len)+': strict mode is turned on but the sublist size doesnt divide the list input evenly. len(l)%sublist_len=='+str(len(l)%sublist_len)+'!=0'
+    if strict and has_len(l):
+        if len(l) % sublist_len != 0:
+            raise ValueError('len(l)=={0} and sublist_len=={1}: strict mode is turned on but the sublist size doesnt divide the list input evenly. len(l)%sublist_len=={2}!=0'.format(len(l), sublist_len, len(l)%sublist_len))
     n=sublist_len
 
-    #This line is rather dense, but it makes sense.
-    output=list(zip(*(iter(l),) * n))+([tuple(l[len(l)-len(l)%n:])] if len(l)%n and keep_remainder else [])
+    #OLD VERSION, DIDNT SUPPORT LAZY: This line is rather dense, but it makes sense.
+    #output=(zip(*(iter(l),) * n))+([tuple(l[len(l)-len(l)%n:])] if len(l)%n and keep_remainder else [])
+    
+    #NEW VERSION: INPUT CAN BE ANY GENERATOR
+    def helper():
+        sublist = []
+        for x in l:
+            sublist.append(x)
+            if len(sublist)==sublist_len:
+                yield sublist
+                sublist = []
+        if sublist:
+            if strict:
+                raise ValueError('strict mode is turned on but the sublist size doesnt divide the list input evenly. remaining elements: {0}'.format(len(sublist)))
+            elif keep_remainder:
+                yield sublist
+                
+    output = helper()
     
+    if not lazy:
+        output=list(output)
+
     if isinstance(l,str):
         output=[''.join(substring) for substring in output]
+    elif not lazy:
+        output=[tuple(sublist) for sublist in output]
 
     return output
 
@@ -20647,16 +20669,25 @@ def pseudo_terminal(
         RS  __import__('os').system('reset')
 
         BLA $r._autoformat_python_code_via_black(str(ans))
+        FLY $refactor_flynt(str(ans))
+        ATC $add_trailing_commas(str(ans))
+        23P $python_2_to_3(str(ans))
+        PUP $refactor_pyupgrade(str(ans))
         SIM $r.sort_imports_via_isort(ans)
-        SIM $r.clean_imports_via_unimport(ans)
+        CIM $r.clean_imports_via_unimport(ans)
+        QIM $r._removestar(ans,qualify=True)
+        RMS $r._removestar(ans)
         SW $r.strip_trailing_whitespace(ans)
+        PWS $propagate_whitespace(ans)
         SPC $r.strip_python_comments(ans)
         SDO $r.strip_python_docstrings(ans)
         D0L $line_join(x for x in str(ans).splitlines() if x.strip())
         UND $unindent(ans)
+        IND $indentify(ans,'    ')
         CBP ans=$string_from_clipboard();ans=$r.autoformat_python_via_black_macchiato(ans);$string_to_clipboard(ans)
         CSP ans=$string_from_clipboard();ans=$sort_imports_via_isort(ans);$string_to_clipboard(ans)
-        RMS $r._removestar(ans)
+        RFS  $remove_fstrings(ans)
+        RMFS $remove_fstrings(ans) #Remove FStrings
 
         DAPI __import__('rp.pypi_inspection').pypi_inspection.display_all_pypi_info()
 
@@ -23260,7 +23291,7 @@ def pseudo_terminal(
                         elif not '\n' in user_message and user_message.startswith('.') and len(user_message)>1 and user_message[1].isalpha():
                             user_message='ans'+user_message
                             fansi_print("Transformed command into " + repr(user_message),'magenta')
-                        elif not '\n' in user_message and user_message.startswith('[') and not user_message.strip().endswith(']') and hasattr(get_ans(),'__getitem__'):
+                        elif not '\n' in user_message and user_message.startswith('[') and not user_message.strip().endswith(']') and hasattr(get_ans(),'__getitem__') and not is_valid_python_syntax(user_message):
                             # Input '[0' would be a syntax error. turn it into 'ans[0]'. Only do this if ans is indexable though.
                             user_message='ans'+user_message+']'
                             fansi_print("Transformed command into " + repr(user_message),'magenta')
@@ -32312,7 +32343,7 @@ def _load_video_stream(location, start_frame=0):
                 return
             yield cv_bgr_rgb_swap(frame)
 
-def load_video_stream(path, *, start_frame=0, with_length=True):
+def load_video_stream(path, *, start_frame=0, with_length=True, frame_transform=None):
     """
     Much faster than load_video, which loads all the frames into a numpy array. This means load_video has to iterate through all the frames before you can even use the first frame.
     load_video_stream is a generator, meaning to get the next frame you use python's builtin 'next' function
@@ -32338,6 +32369,9 @@ def load_video_stream(path, *, start_frame=0, with_length=True):
 
     frame_iterator = _load_video_stream(path, start_frame=start_frame)
 
+    if frame_transform is not None:
+        frame_iterator = map(frame_transform, frame_iterator)
+
     if with_length:
         try:
             num_frames = get_video_file_num_frames(path)
@@ -32353,6 +32387,7 @@ def load_video_streams(
     *paths,
     start_frame=0,
     with_length=True,
+    frame_transform=None,
     transpose=False,
 
     show_progress=True,
@@ -32372,7 +32407,7 @@ def load_video_streams(
     assert len(start_frame)==len(paths), 'Must specify start_frame for each video'
 
     def load(i):
-        return load_video_stream(paths[i], start_frame=start_frame[i], with_length=with_length)
+        return load_video_stream(paths[i], start_frame=start_frame[i], with_length=with_length, frame_transform=frame_transform)
 
     streams = gather_args_call(load_files, load, range(len(paths)))
         
@@ -32390,7 +32425,7 @@ def load_video_streams(
 
 
 _load_video_cache = {}
-def load_video(path, *, start_frame=0, length=None, show_progress=True, use_cache=False):
+def load_video(path, *, start_frame=0, length=None, show_progress=True, use_cache=False, frame_transform=None):
     """
     This function does not take into account framerates or audio. It just returns a numpy array full of images.
     It's slower to call than load_video_stream, but it can be cached using use_cache (which would actually make it faster, if applicable)
@@ -32403,6 +32438,7 @@ def load_video(path, *, start_frame=0, length=None, show_progress=True, use_cach
                                         Setting this to False can result in a small performance boost, as it won't 
                                         check the length of the video (which might take a small bit of time)
         use_cache (bool, optional): Whether to cache the loaded video for faster subsequent loading. Defaults to False.
+        frame_transform (callable, optional): If specified, transforms each frame with this function.
 
     Returns:
         numpy.ndarray: A NumPy array containing the loaded video frames in THWC form.
@@ -32430,10 +32466,11 @@ def load_video(path, *, start_frame=0, length=None, show_progress=True, use_cach
     if path_exists(path):
         path = get_absolute_path(path)  # This is important for caching.
     
-    if use_cache and path in _load_video_cache:
-        return _load_video_cache[path]
+    cache_id = (path, start_frame, length, frame_transform)
+    if use_cache and cache_id in _load_video_cache:
+        return _load_video_cache[cache_id]
     
-    stream = load_video_stream(path, start_frame = start_frame, with_length=show_progress)
+    stream = load_video_stream(path, start_frame = start_frame, with_length=show_progress, frame_transform=frame_transform)
     out = []
     
     for i, frame in enumerate(stream):
@@ -32462,7 +32499,7 @@ def load_video(path, *, start_frame=0, length=None, show_progress=True, use_cach
         print(end='done.\r\n')
     
     if use_cache:
-        _load_video_cache[path] = out
+        _load_video_cache[cache_id] = out
     
     return out
 
@@ -32471,6 +32508,7 @@ def load_videos(
     *paths,
     start_frame=0,
     length=None,
+    frame_transform=None,
     show_progress=True,
     use_cache=False,
     num_threads=None,
@@ -32500,6 +32538,7 @@ def load_videos(
             length=length,
             show_progress=False,
             use_cache=use_cache,
+            frame_transform=frame_transform,
         )
 
     return gather_args_call(load_files, load, paths)
@@ -46035,6 +46074,9 @@ def unwarped_perspective_image(image, from_points, to_points=None, height:int=No
     Height and width can be manually specified as well, in case you want to capture parts of the perspectie transform that might have been cropped out
     When to_points is not specified, we assume that the from_points start from the top left of the desired area, and progress clockwise
 
+    Works on byte images and floating point images of float64 or float32
+    Works on RGB, RGBA and grayscale images natively
+
     The sister function is rp.unwarped_perspective_contour
 
     If to_points is not specified, from_points should start from the top left and go clockwise to the other 3 points
@@ -46072,8 +46114,11 @@ def unwarped_perspective_image(image, from_points, to_points=None, height:int=No
     pip_import('cv2')
     import cv2
     
-    image=as_rgb_image (image)
-    image=as_byte_image(image)
+    #Not necessary - it can work on flaying point images, float32 and float64 - on both grayscale matrices, RGB and RGBA images
+    # image=as_rgb_image (image)
+    # image=as_byte_image(image)
+    if is_binary_image(image):
+        image = as_byte_image(image)
     
     if width  is None:width =get_image_width (image)
     if height is None:height=get_image_height(image)
@@ -47942,6 +47987,16 @@ def autoformat_html_via_bs4(code: str) -> str:
 
 autoformat_html = autoformat_html_via_bs4
 
+def add_trailing_commas(code: str) -> str:
+    """
+    https://github.com/asottile/add-trailing-comma
+    
+    """
+    pip_import("add_trailing_comma")
+    from add_trailing_comma._main import _fix_src
+
+    return _fix_src(code)
+
 
 def autoformat_json(data, indent=4):
     """
@@ -48851,13 +48906,115 @@ def get_star_modules(code):
     code=[x[len('from '):-len(' import *')].strip() for x in code]
     return sorted(set(code))
 
-def refactor_fstrings(code):
+def remove_fstrings(code):
     """
     Removes f-strings, using str.format notation instead. This is good for making code backwards-compatiable with python 3.5
     """
     from rp.libs.refactor.string_format.fstring_converter import convert_string
     return convert_string(code)
 
+# def refactor_pyupgrade(
+#     code: str,
+#     min_version: tuple[int, ...] = (3,),
+#     keep_percent_format: bool = False,
+#     keep_mock: bool = False,
+#     keep_runtime_typing: bool = False
+# ) -> str:
+#     """Modernize Python code by upgrading syntax to newer versions.
+#
+#     Args:
+#         code: Python source code to modernize
+#         min_version: Target Python version tuple, e.g. (3, 8) for Python 3.8+
+#             - (3,): Basic Python 3 upgrades (dict() → {}, .keys() → list())
+#             - (3, 6): f-strings, variable annotations
+#             - (3, 8): Positional-only params, := operator
+#             - (3, 10): Union[X, Y] → X | Y, match statements
+#         keep_percent_format: Don't upgrade % formatting → .format()
+#             - True: keeps "Hello %s" % name
+#             - False: converts to "Hello {}".format(name)
+#         keep_mock: Don't upgrade mock imports
+#             - True: keeps "from mock import Mock"
+#             - False: converts to "from unittest.mock import Mock"
+#         keep_runtime_typing: Don't remove typing imports only used in annotations
+#             - True: keeps "from typing import List" even if only in type hints
+#             - False: removes unused typing imports when min_version supports built-ins
+#
+#     Returns:
+#         Modernized Python source code
+#     """
+#     import pyupgrade._main
+#     from pyupgrade._data import Settings
+#
+#     settings = Settings(
+#         min_version=min_version,
+#         keep_percent_format=keep_percent_format,
+#         keep_mock=keep_mock,
+#         keep_runtime_typing=keep_runtime_typing,
+#     )
+#
+#     # Apply plugin fixes
+#     refactored_code = pyupgrade._main._fix_plugins(code, settings)
+#
+#     # Apply token fixes
+#     refactored_code = pyupgrade._main._fix_tokens(refactored_code)
+#
+#     return refactored_code
+
+def refactor_flynt(
+    code: str,
+    *,
+    aggressive: bool = False,
+    multiline: bool = True,
+    len_limit: int = None,
+    percent: bool = True,
+    format: bool = True,
+    concat: bool = False,
+    join: bool = False
+) -> str:
+    """
+    Refactor Python code using flynt to convert to f-strings.
+
+    Args:
+        code: Python source code to refactor
+        aggressive: Use aggressive mode for transformations
+        multiline: Allow multiline f-strings
+        len_limit: Length limit for f-strings (None for no limit)
+        percent: Transform %-style formatting to f-strings
+        format: Transform .format() calls to f-strings
+        concat: Transform string concatenations to f-strings
+        join: Transform static string joins to f-strings
+
+    Returns:
+        Refactored Python code as string
+    """
+    from flynt.api import fstringify_code
+    from flynt.state import State
+
+    # Create state with provided options
+    state = State(
+        quiet=True,  # Don't print reports
+        dry_run=False,  # Apply changes
+        stdout=False,  # Don't print to stdout
+        aggressive=aggressive,
+        multiline=multiline,
+        len_limit=len_limit,
+        transform_percent=percent,
+        transform_format=format,
+        transform_concat=concat,
+        transform_join=join,
+    )
+
+    # Apply flynt transformations
+    result = fstringify_code(code, state)
+
+    if result is None:
+        return code  # Return original if transformation failed
+
+    return result.content
+
+
+
+
 def file_line_iterator(file_name, *, with_len=False):
     """
     Opens a file and iterates through its lines.
@@ -50780,6 +50937,7 @@ known_pypi_module_package_names={
     '_sentencepiece': 'sentencepiece',
     '_sounddevice': 'sounddevice',
     'absl': 'absl-py',
+    'add_trailing_comma' : 'add-trailing-comma',
     'ahocorasick': 'pyahocorasick',
     'async_timeout': 'async-timeout',
     'atari_py': 'atari-py',

{rp-0.1.1280 → rp-0.1.1282}/rp/rp_ptpython/key_bindings.py

@@ -1297,6 +1297,22 @@ def handle_character(buffer,char,event=None):
         meta_pressed(clear=True)
         return True
 
+    if char==' ' and before=='[' and after==']':
+        # [|] --> [ans|]
+        buffer.insert_text('ans')
+        return True
+
+    if char==' ' and before.endswith(']') and after.startswith(']'):
+        # [[ans]|] --> [[ans],|]
+        buffer.insert_text(',')
+        return True
+
+    if char==' ' and before.endswith('],') and after.startswith(']'):
+        # [[ans],|] --> [[ans]]|
+        buffer.delete_before_cursor()
+        buffer.cursor_right()
+        return True
+
     if char=='`' and meta_pressed(clear=False):
         #Toggle shell mode! Couldn't do alt+1 that's taken, so ` is nearby...
 

rp-0.1.1282/rp/version.py

@@ -0,0 +1 @@
+1282

{rp-0.1.1280 → rp-0.1.1282}/rp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: rp
-Version: 0.1.1280
+Version: 0.1.1282
 Summary: Ryan's Python
 Home-page: https://github.com/RyannDaGreat/Quick-Python
 Author: Ryan Burgert

rp-0.1.1282/version.py

@@ -0,0 +1 @@
+1282

rp-0.1.1280/rp/version.py

@@ -1 +0,0 @@
-1280

rp-0.1.1280/version.py

@@ -1 +0,0 @@
-1280