rp 0.1.1216__tar.gz → 0.1.1218__tar.gz

{rp-0.1.1216 → rp-0.1.1218}/PKG-INFO

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

rp-0.1.1218/rp/prompt_toolkit/layout/mouse_handlers.py

@@ -0,0 +1,81 @@
+from __future__ import unicode_literals
+
+from collections import defaultdict
+
+__all__ = (
+    'MouseHandlers',
+)
+
+
+class _Rect:
+    """
+    Internal rectangle class for efficient mouse handler regions.
+    """
+    def __init__(self, x_min, x_max, y_min, y_max, handler):
+        self.x_min = x_min
+        self.x_max = x_max
+        self.y_min = y_min
+        self.y_max = y_max
+        self.handler = handler
+    
+    def contains(self, x, y):
+        """
+        Check if the point (x, y) is within this rectangle.
+        """
+        return (self.x_min <= x < self.x_max and 
+                self.y_min <= y < self.y_max)
+
+
+class RectDict:
+    """
+    Dictionary-like class that efficiently stores rectangle regions and their handlers.
+    """
+    def __init__(self, default_factory):
+        self._default_factory = default_factory
+        self._default_value = default_factory()
+        self._rects = []
+        
+    def __getitem__(self, key):
+        """
+        Get handler for a specific (x, y) position.
+        """
+        x, y = key
+        
+        # Check through rectangles in order (most recently added first)
+        for rect in self._rects:
+            if rect.contains(x, y):
+                return rect.handler
+                
+        # Return default value if no rectangle contains this point
+        return self._default_value
+    
+    def __setitem__(self, key, value):
+        """
+        For individual points (legacy support and special cases)
+        """
+        x, y = key
+        # Create a 1x1 rectangle for this point
+        rect = _Rect(x, x+1, y, y+1, value)
+        self._rects.insert(0, rect)
+
+
+class MouseHandlers(object):
+    """
+    Two dimentional raster of callbacks for mouse events.
+    """
+    def __init__(self):
+        def dummy_callback(cli, mouse_event):
+            """
+            :param mouse_event: `MouseEvent` instance.
+            """
+
+        # Map (x,y) tuples to handlers using our optimized RectDict
+        self.mouse_handlers = RectDict(lambda: dummy_callback)
+
+    def set_mouse_handler_for_range(self, x_min, x_max, y_min, y_max, handler=None):
+        """
+        Set mouse handler for a region.
+        """
+        # Add rectangle directly to the RectDict's internal rect list - O(1) operation
+        rect = _Rect(x_min, x_max, y_min, y_max, handler)
+        self.mouse_handlers._rects.insert(0, rect)

{rp-0.1.1216 → rp-0.1.1218}/rp/r.py

@@ -9336,11 +9336,14 @@ def rebind_globals_to_module(module, *, monkey_patch=False):
     return decorator
 
 
-def globals_macro(func):
+def globalize_locals(func):
     """
-    Decorator that makes a function's local variables available globally.
+    Decorator that makes a function's local variables available globally,
+    allowing a function to effectively act as a macro.
+
+    Useful for making reusable cells in a Jupyter notebook.
     
-    When a function decorated with @globals_macro is called, all local variables created
+    When a function decorated with @globalize_locals is called, all local variables created
     within the function become available in the global namespace after execution.
     This includes both function parameters and local variables.
     
@@ -9353,7 +9356,7 @@ def globals_macro(func):
         >>> 'x' in globals(), 'y' in globals(), 'z' in globals()
         (False, False, False)
         
-        >>> @globals_macro
+        >>> @globalize_locals
         ... def f(x, y):
         ...     z = x + y
         >>> f(1, 2)
@@ -9364,7 +9367,7 @@ def globals_macro(func):
     
     Example (With Error):
         >>> # Variables are still preserved even when an error occurs
-        >>> @globals_macro
+        >>> @globalize_locals
         ... def f(x, y):
         ...     1/0  # Division by zero error
         ...     z = x + y  # This line never executes
@@ -9380,6 +9383,44 @@ def globals_macro(func):
         >>> # But z isn't defined since that line never executed
         >>> 'z' in globals()
         False
+
+    Example:
+        >>> @globalize_locals
+        ... def part_0a():
+        ...     url = "https://www.pupsgonewild.com/s/cc_images/cache_7853498.jpg"
+        ... 
+        ... 
+        ... @globalize_locals
+        ... def part_0b():
+        ...     url = "https://mortenhannemose.github.io/assets/img/Lena_1024.png"
+        ... 
+        ... 
+        ... @globalize_locals
+        ... def part_0c():
+        ...     url = "https://res.cloudinary.com/lancaster-puppies-laravel/image/upload/$date_!12%252F26%252F2024!/t_lpr-full-transform/t_lpr-date-transform/r_16/v1/default/eoxl4syekwivgrdgze5u?_a=AJAJZWI0"
+        ... 
+        ... 
+        ... @globalize_locals
+        ... def part_1():
+        ...     image = load_image(url)
+        ... 
+        ... 
+        ... @globalize_locals
+        ... def part_2():
+        ...     images = []
+        ...     for part_0 in [part_0a, part_0b, part_0c]:
+        ...         part_0()
+        ...         part_1()
+        ...         images.append(image)
+        ... 
+        ... 
+        ... @globalize_locals
+        ... def part_3():
+        ...     part_2()
+        ...     display_image(horizontally_concatenated_images(images))
+        ... 
+        ... 
+        ... part_3()
     """
     import inspect
     import functools
@@ -16944,6 +16985,14 @@ _default_pyin_settings=dict(
     highlight_cursor_column=False ,# Highlight the background of the cursor column
     highlight_matching_words=True  ,# Underline all occurrences of the word under cursor
     show_whitespace=True,
+    
+    # Color customization settings
+    code_invert_colors=False,     # Invert colors for code syntax highlighting
+    code_invert_brightness=False, # Invert brightness for code syntax highlighting
+    ui_invert_colors=False,       # Invert colors for UI elements (hidden by default)
+    ui_invert_brightness=False,   # Invert brightness for UI elements (hidden by default)
+    code_hue_shift=0,             # Hue shift for code syntax highlighting (0-355 degrees in 5-degree increments)
+    ui_hue_shift=0,               # Hue shift for UI elements (0-355 degrees in 5-degree increments, hidden by default)
 
     session_title='',
 )
@@ -19996,6 +20045,7 @@ def pseudo_terminal(
         IGN       $r._write_default_gitignore()
         IGNORE    $r._write_default_gitignore()
         GIG       $r._write_default_gitignore()
+        GPL !git pull
 
         PPTA $r._convert_powerpoint_file(ans)
         PPT $r._convert_powerpoint_file($input_select_file(file_extension_filter='pptx'),message='Select a powerpoint file')
@@ -27281,6 +27331,9 @@ def as_rgba_float_color(color,*,clamp=True):
     assert len(color) == 4 
     if clamp:
         color = tuple(max(0,min(1,x)) for x in color)
+
+    color = tuple(map(float,color)) #Make sure they're all floats! 
+
     return color
 
 def as_rgb_float_color(color, clamp=True):
@@ -29744,8 +29797,8 @@ def byte_color_to_float_color(byte_color):
 def float_color_to_byte_color(float_color):
     return tuple(round(clamp(x*255,0,255)) for x in float_color)
 
-def float_color_to_hex_color(float_color):
-    return byte_color_to_hex_color(float_color_to_byte_color(float_color))
+def float_color_to_hex_color(float_color, hashtag=True):
+    return byte_color_to_hex_color(float_color_to_byte_color(float_color),hashtag=hashtag)
 
 _altbw_flipflop=False
 def _altbw():
@@ -35048,6 +35101,89 @@ def get_scope(frames_back=0):
 
     return {'locals':frame.f_locals, 'globals':frame.f_globals}[scope]
 
+
+def _get_visible_scope(frames_back=0):
+    """
+    Treat the output as read-only! Will include all variables that can be seen from that point.
+
+    Should be an improved form of get_scope, but to avoid breaking other code (just in case), I'm making this a private helper for rp internals.
+    
+    Get the scope of n levels up from the current stack frame,
+    including all globals, locals, and variables from enclosing scopes.
+    
+    Parameters:
+    frames_back (int): How many frames to go up in the stack. 0 means the calling function's frame.
+    
+    Returns:
+    dict: A dictionary with all variables from globals, locals, and enclosing scopes.
+
+    EXAMPLE:
+        >>> import rp
+        ... y=456
+        ... def f():
+        ...     x=123
+        ...     def g():
+        ...         print(rp.repr_kwargs_dict(rp.r._get_visible_scope()))
+        ...     g()
+        ... f()
+        dict(
+             __name__        = '__main__',
+             __doc__         = None,
+             __package__     = None,
+             __loader__      = <_frozen_importlib_external.SourceFileLoader object at 0x104e90530>,
+             __spec__        = None,
+             __annotations__ = {},
+             __builtins__    = <module 'builtins' (built-in)>,
+             __file__        = '/Users/burgert/CleanCode/Sandbox/test.py',
+             __cached__      = None,
+             rp              = <module 'rp' from '/Users/burgert/miniconda3/lib/python3.12/site-packages/rp/__init__.py'>,
+             y               = 456,
+             f               = <function f at 0x104e6e340>,
+             x               = 123,
+             g               = <function f.<locals>.g at 0x104ef5760>,
+        )
+
+    """
+    assert isinstance(frames_back, int), 'frames_back must be an integer'
+    assert frames_back >= 0, 'frames_back cannot be negative'
+
+    import inspect
+
+    frame = inspect.currentframe()
+    frame = frame.f_back  # Don't return the scope for this function
+    for _ in range(frames_back):
+        frame = frame.f_back
+        if frame is None:
+            break
+
+    # Create result dict with both globals and locals
+    result = {}
+    result.update(frame.f_globals)
+    result.update(frame.f_locals)
+    
+    # Check for variables in enclosing scopes
+    current = frame
+    # Handle freevars (variables from enclosing scopes)
+    if hasattr(current, 'f_code') and hasattr(current.f_code, 'co_freevars'):
+        # Get a list of all outer frames
+        frames = []
+        outer = current.f_back
+        while outer:
+            frames.append(outer)
+            outer = outer.f_back
+        
+        # Process each frame from innermost to outermost
+        for outer_frame in frames:
+            if outer_frame.f_locals:
+                # Check each local in the outer frame
+                for name, value in outer_frame.f_locals.items():
+                    # Add it if it's not already in our result
+                    if name not in result:
+                        result[name] = value
+    
+    return result
+
+
 _all_module_names=set()
 def get_all_importable_module_names(use_cache=True):
     """
@@ -38613,14 +38749,36 @@ def get_sinusoidal_positional_encodings(length: int, dim: int, scale: float = 10
 #    return _visualize_pytorch_model_via_torchviz(model,input_shape=input_shape,example_input=example_input)
 
 def inverted_color(color):
-    if   is_binary_color(color):
-        return tuple(not x for x in color)
-    elif is_byte_color(color):
-        return tuple(255-x for x in color)
-    elif is_float_color(color):
-        return tuple(1-x for x in color)
+    """
+        >>> inverted_color('#00FF00')      --->  #FF00FF               #If given color is in hex form, keep the hashtag
+        >>> inverted_color('00FF00')       --->  FF00FF                #Or if given color is hex with no hashtag, dont include hashtag
+        >>> inverted_color((255,0,0))      --->  (0, 255, 255)         #Works with byte colors
+        >>> inverted_color((1,0,0))        --->  (254, 255, 255)       #If colors are ints, are treated as bytes
+        >>> inverted_color((1.0,0,0))      --->  (0.0, 1, 1)           #Float colors treated differently
+        >>> inverted_color((1.,0.,0.,0.))  --->  (0.0, 1.0, 1.0, 0.0)  #Alpha is not inverted, it is kept the same
+        >>> inverted_color((1.,0.,0.,1.))  --->  (0.0, 1.0, 1.0, 1.0)  #(ditto to above)
+        >>> inverted_color('green')        --->  (1.0, 0.0, 1.0, 1.0)  #If a string is given, compatiable with as_rgba_float_color, return a float color
+    """
+    if   is_binary_color(color): return tuple(not x for x in color[:3])+tuple(color[3:])
+    elif is_byte_color(color)  : return tuple(255-x for x in color[:3])+tuple(color[3:])
+    elif is_float_color(color) : return tuple(1-x   for x in color[:3])+tuple(color[3:])
+    elif isinstance(color, str):
+        hashtag = color.startswith('#')
+        if hashtag:
+            color = color[1:]
+
+        is_hex = len(color) == 6 and set(color) <= set("0123456789abcdefABCDEF")
+
+        output = inverted_color(
+            as_rgba_float_color(color),
+        )
+
+        if is_hex:
+            output = float_color_to_hex_color(output, hashtag=hashtag)
+
+        return output
     else:
-        raise TypeError('Unknown color format')
+        raise TypeError('Unknown color format: '+repr(color))
 
 def inverted_image(image,invert_alpha=False):
     """ Inverts the colors of an image. By default, it doesn't touch the alpha channel (if one exists) """
@@ -40804,7 +40962,7 @@ def validate_tensor_shapes(*, verbose=False, **kwargs):
         return ','.join(map(str, shape))
 
     # Get the caller's scope to find tensor variables
-    caller_scope = get_scope(1)
+    caller_scope = _get_visible_scope(1)
     
     # Separate dimension constraints from tensor form strings
     dim_constraints = {}

{rp-0.1.1216 → rp-0.1.1218}/rp/rp_ptpython/key_bindings.py

@@ -94,7 +94,37 @@ def is_iterable_token(token_name):
 
     
 
+def edit_event_buffer_in_external(event,cmd):
+        buffer=event.cli.current_buffer
+        document=buffer.document
+        text=buffer.document.text   
+        from rp import text_file_to_string,temporary_file_path,string_to_text_file
+        import subprocess
+
+        path=temporary_file_path()+'.py'
+        string_to_text_file(path,text)
+
+        try:
+            subprocess.call([cmd,path])
+
+            text=text_file_to_string(path)
+
+            from rp import delete_file
+            delete_file(path)
+
+            if text!='':
+                #That means the user saved the file
+                buffer.document=Document(text,min(len(text),buffer.document.cursor_position),buffer.document.selection)
+
+            event.cli.renderer.clear()#Refresh the screen
+
+        except Exception as e:
+            buffer.insert_text('#'+str(e))
+
+
 
+def edit_event_buffer_in_nano(event): edit_event_buffer_in_external(event,'nano')
+def edit_event_buffer_in_micro(event): edit_event_buffer_in_external(event,'micro')
 def edit_event_buffer_in_vim(event):
         buffer=event.cli.current_buffer
         document=buffer.document
@@ -2706,6 +2736,8 @@ def load_python_bindings(python_input):
                                          '\\wco':'web_copy',
                                          '\\ed':'editor',
                                          '\\vi':'vim',
+                                         '\\mi':'micro',
+                                         '\\na':'nano',
                                          '\\al':'align_lines',
                                          '\\ac':'align_char',
                                          '\\sw':'strip_whitespace',
@@ -3259,6 +3291,10 @@ def load_python_bindings(python_input):
                                         buffer.insert_text("#ERROR: Cannot import 'editor'. Try pip install python-editor")
                                 if header=='vim':
                                     edit_event_buffer_in_vim(event)
+                                if header=='micro':
+                                    edit_event_buffer_in_micro(event)
+                                if header=='nano':
+                                    edit_event_buffer_in_nano(event)
                                 if header=='save' or header=='string ans':#header=='save' because of the conflict of \sa in the dict
                                     buffer.insert_text(repr(str(get_ans())))
                                 if header=='ans':

{rp-0.1.1216 → rp-0.1.1218}/rp/rp_ptpython/python_input.py

@@ -234,6 +234,12 @@ class PythonInput(object):
         self.ui_styles=get_all_ui_styles()
         self._current_code_style_name='default'
         self._current_ui_style_name='default'
+        self.code_invert_colors=False
+        self.code_invert_brightness=False
+        self.ui_invert_colors=False
+        self.ui_invert_brightness=False
+        self.code_hue_shift=0  # Hue shift for code elements (0-355 degrees in 5-degree increments)
+        self.ui_hue_shift=0    # Hue shift for UI elements (0-355 degrees in 5-degree increments)
 
         if is_windows():
             self._current_code_style_name='win32'
@@ -374,7 +380,20 @@ class PythonInput(object):
         renderer receives a new style class, he will redraw everything.)
         """
         return generate_style(self.code_styles[self._current_code_style_name],
-                              self.ui_styles[self._current_ui_style_name])
+                              self.ui_styles[self._current_ui_style_name],
+                              code_invert_colors=self.code_invert_colors,
+                              code_invert_brightness=self.code_invert_brightness,
+                              ui_invert_colors=self.ui_invert_colors,
+                              ui_invert_brightness=self.ui_invert_brightness,
+                              code_hue_shift=self.code_hue_shift,
+                              ui_hue_shift=self.ui_hue_shift)
+                              
+    def _update_style(self):
+        """
+        Update the current style. Used when toggling the invert_colors option.
+        """
+        self._current_style = self._generate_style()
+        return True
     def _create_options(self):
         """
         Create a list of `Option` instances for the options sidebar.
@@ -825,6 +844,51 @@ class PythonInput(object):
                        get_values=lambda:dict(
                            (name,partial(self.use_ui_colorscheme,name)) for name in self.ui_styles)
                        ),
+                Option(title='Invert Code Colors',
+                       description='Invert foreground and background colors for code syntax highlighting.',
+                       get_current_value=lambda: ['off', 'on'][self.code_invert_colors],
+                       get_values=lambda:{
+                           'on': lambda: setattr(self, 'code_invert_colors', True) or self._update_style(),
+                           'off': lambda: setattr(self, 'code_invert_colors', False) or self._update_style(),
+                       }),
+                Option(title='Invert Code Brightness',
+                       description='Invert brightness of code syntax highlighting while preserving color hue.',
+                       get_current_value=lambda: ['off', 'on'][self.code_invert_brightness],
+                       get_values=lambda:{
+                           'on': lambda: setattr(self, 'code_invert_brightness', True) or self._update_style(),
+                           'off': lambda: setattr(self, 'code_invert_brightness', False) or self._update_style(),
+                       }),
+                Option(title='Invert UI Colors',
+                       description='Invert foreground and background colors for UI elements.',
+                       is_visible=lambda: getattr(self, 'show_all_options', False),
+                       get_current_value=lambda: ['off', 'on'][self.ui_invert_colors],
+                       get_values=lambda:{
+                           'on': lambda: setattr(self, 'ui_invert_colors', True) or self._update_style(),
+                           'off': lambda: setattr(self, 'ui_invert_colors', False) or self._update_style(),
+                       }),
+                Option(title='Invert UI Brightness',
+                       description='Invert brightness of UI elements while preserving color hue.',
+                       is_visible=lambda: getattr(self, 'show_all_options', False),
+                       get_current_value=lambda: ['off', 'on'][self.ui_invert_brightness],
+                       get_values=lambda:{
+                           'on': lambda: setattr(self, 'ui_invert_brightness', True) or self._update_style(),
+                           'off': lambda: setattr(self, 'ui_invert_brightness', False) or self._update_style(),
+                       }),
+                Option(title='Code Hue Shift',
+                       description='Shift the hue of code syntax highlighting by the specified number of degrees.',
+                       get_current_value=lambda: '{:03d}'.format(self.code_hue_shift),
+                       get_values=lambda: dict(
+                           ('{:03d}'.format(degrees), lambda degrees=degrees: setattr(self, 'code_hue_shift', degrees) or self._update_style())
+                           for degrees in range(0, 360, 5)
+                       )),
+                Option(title='UI Hue Shift',
+                       description='Shift the hue of UI elements by the specified number of degrees.',
+                       is_visible=lambda: getattr(self, 'show_all_options', False),
+                       get_current_value=lambda: '{:03d}'.format(self.ui_hue_shift),
+                       get_values=lambda: dict(
+                           ('{:03d}'.format(degrees), lambda degrees=degrees: setattr(self, 'ui_hue_shift', degrees) or self._update_style())
+                           for degrees in range(0, 360, 5)
+                       )),
                 simple_option(title='True color (24 bit)',
                         # is_visible=lambda:getattr(self,'show_all_options',True),