rp 0.1.1217__tar.gz → 0.1.1219__tar.gz

{rp-0.1.1217 → rp-0.1.1219}/PKG-INFO

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

rp-0.1.1219/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.1217 → rp-0.1.1219}/rp/r.py

@@ -9336,13 +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.
     
@@ -9355,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)
@@ -9366,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
@@ -9384,27 +9385,27 @@ def globals_macro(func):
         False
 
     Example:
-        >>> @globals_macro
+        >>> @globalize_locals
         ... def part_0a():
         ...     url = "https://www.pupsgonewild.com/s/cc_images/cache_7853498.jpg"
         ... 
         ... 
-        ... @globals_macro
+        ... @globalize_locals
         ... def part_0b():
         ...     url = "https://mortenhannemose.github.io/assets/img/Lena_1024.png"
         ... 
         ... 
-        ... @globals_macro
+        ... @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"
         ... 
         ... 
-        ... @globals_macro
+        ... @globalize_locals
         ... def part_1():
         ...     image = load_image(url)
         ... 
         ... 
-        ... @globals_macro
+        ... @globalize_locals
         ... def part_2():
         ...     images = []
         ...     for part_0 in [part_0a, part_0b, part_0c]:
@@ -9413,7 +9414,7 @@ def globals_macro(func):
         ...         images.append(image)
         ... 
         ... 
-        ... @globals_macro
+        ... @globalize_locals
         ... def part_3():
         ...     part_2()
         ...     display_image(horizontally_concatenated_images(images))
@@ -16984,6 +16985,22 @@ _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)
+    code_min_brightness=0.0,      # Minimum brightness for code elements (0.0-1.0)
+    code_max_brightness=1.0,      # Maximum brightness for code elements (0.0-1.0)
+    ui_min_brightness=0.0,        # Minimum brightness for UI elements (0.0-1.0)
+    ui_max_brightness=1.0,        # Maximum brightness for UI elements (0.0-1.0)
+    code_min_saturation=0.0,      # Minimum saturation for code elements (0.0-1.0)
+    code_max_saturation=1.0,      # Maximum saturation for code elements (0.0-1.0)
+    ui_min_saturation=0.0,        # Minimum saturation for UI elements (0.0-1.0)
+    ui_max_saturation=1.0,        # Maximum saturation for UI elements (0.0-1.0)
 
     session_title='',
 )
@@ -20036,6 +20053,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')
@@ -27321,6 +27339,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):
@@ -29784,8 +29805,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():
@@ -38736,14 +38757,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) """

{rp-0.1.1217 → rp-0.1.1219}/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.1217 → rp-0.1.1219}/rp/rp_ptpython/python_input.py

@@ -234,6 +234,20 @@ 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)
+        self.code_min_brightness=0.0  # Minimum brightness for code elements (0.0-1.0)
+        self.code_max_brightness=1.0  # Maximum brightness for code elements (0.0-1.0)
+        self.ui_min_brightness=0.0    # Minimum brightness for UI elements (0.0-1.0)
+        self.ui_max_brightness=1.0    # Maximum brightness for UI elements (0.0-1.0)
+        self.code_min_saturation=0.0  # Minimum saturation for code elements (0.0-1.0)
+        self.code_max_saturation=1.0  # Maximum saturation for code elements (0.0-1.0)
+        self.ui_min_saturation=0.0    # Minimum saturation for UI elements (0.0-1.0)
+        self.ui_max_saturation=1.0    # Maximum saturation for UI elements (0.0-1.0)
 
         if is_windows():
             self._current_code_style_name='win32'
@@ -374,7 +388,28 @@ 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,
+                              code_min_brightness=self.code_min_brightness,
+                              code_max_brightness=self.code_max_brightness,
+                              ui_min_brightness=self.ui_min_brightness,
+                              ui_max_brightness=self.ui_max_brightness,
+                              code_min_saturation=self.code_min_saturation,
+                              code_max_saturation=self.code_max_saturation,
+                              ui_min_saturation=self.ui_min_saturation,
+                              ui_max_saturation=self.ui_max_saturation)
+                              
+    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.
@@ -813,21 +848,137 @@ class PythonInput(object):
                        }),
             ]),
             OptionCategory('Color Themes',[
+                # Code-related options
                 Option(title='Code',
                        description='Color scheme to use for the Python code.',
-                       get_current_value=lambda:self._current_code_style_name,
+                       get_current_value=lambda:self._current_code_style_name[:15],
                        get_values=lambda:dict(
                            (name,partial(self.use_code_colorscheme,name)) for name in self.code_styles)
                        ),
+                Option(title='Invert Code Colors',
+                       description='Invert foreground and background colors for code syntax highlighting.',
+                       is_visible=lambda: getattr(self, 'show_all_options', False),
+                       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.',
+                       is_visible=lambda: getattr(self, 'show_all_options', False),
+                       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='Code Hue Shift',
+                       description='Shift the hue of code syntax highlighting by the specified number of degrees.',
+                       is_visible=lambda: getattr(self, 'show_all_options', False),
+                       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='Code Min Brightness',
+                       description='Set the minimum brightness level for code elements.',
+                       is_visible=lambda: getattr(self, 'show_all_options', False),
+                       get_current_value=lambda: '{:.1f}'.format(self.code_min_brightness),
+                       get_values=lambda: dict(
+                           ('{:.1f}'.format(value/10), lambda value=value: setattr(self, 'code_min_brightness', value/10) or self._update_style())
+                           for value in range(0, 11)
+                       )),
+                Option(title='Code Max Brightness',
+                       description='Set the maximum brightness level for code elements.',
+                       is_visible=lambda: getattr(self, 'show_all_options', False),
+                       get_current_value=lambda: '{:.1f}'.format(self.code_max_brightness),
+                       get_values=lambda: dict(
+                           ('{:.1f}'.format(value/10), lambda value=value: setattr(self, 'code_max_brightness', value/10) or self._update_style())
+                           for value in range(0, 11)
+                       )),
+                Option(title='Code Min Saturation',
+                       description='Set the minimum saturation level for code elements.',
+                       is_visible=lambda: getattr(self, 'show_all_options', False),
+                       get_current_value=lambda: '{:.1f}'.format(self.code_min_saturation),
+                       get_values=lambda: dict(
+                           ('{:.1f}'.format(value/10), lambda value=value: setattr(self, 'code_min_saturation', value/10) or self._update_style())
+                           for value in range(0, 11)
+                       )),
+                Option(title='Code Max Saturation',
+                       description='Set the maximum saturation level for code elements.',
+                       is_visible=lambda: getattr(self, 'show_all_options', False),
+                       get_current_value=lambda: '{:.1f}'.format(self.code_max_saturation),
+                       get_values=lambda: dict(
+                           ('{:.1f}'.format(value/10), lambda value=value: setattr(self, 'code_max_saturation', value/10) or self._update_style())
+                           for value in range(0, 11)
+                       )),
+                
+                # UI-related options
                 Option(title='User Interface',
                        description='Color scheme to use for the user interface.',
-                       get_current_value=lambda:self._current_ui_style_name,
+                       get_current_value=lambda:self._current_ui_style_name[:15],
                        get_values=lambda:dict(
                            (name,partial(self.use_ui_colorscheme,name)) for name in self.ui_styles)
                        ),
+                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='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)
+                       )),
+                Option(title='UI Min Brightness',
+                       description='Set the minimum brightness level for UI elements.',
+                       is_visible=lambda: getattr(self, 'show_all_options', False),
+                       get_current_value=lambda: '{:.1f}'.format(self.ui_min_brightness),
+                       get_values=lambda: dict(
+                           ('{:.1f}'.format(value/10), lambda value=value: setattr(self, 'ui_min_brightness', value/10) or self._update_style())
+                           for value in range(0, 11)
+                       )),
+                Option(title='UI Max Brightness',
+                       description='Set the maximum brightness level for UI elements.',
+                       is_visible=lambda: getattr(self, 'show_all_options', False),
+                       get_current_value=lambda: '{:.1f}'.format(self.ui_max_brightness),
+                       get_values=lambda: dict(
+                           ('{:.1f}'.format(value/10), lambda value=value: setattr(self, 'ui_max_brightness', value/10) or self._update_style())
+                           for value in range(0, 11)
+                       )),
+                Option(title='UI Min Saturation',
+                       description='Set the minimum saturation level for UI elements.',
+                       is_visible=lambda: getattr(self, 'show_all_options', False),
+                       get_current_value=lambda: '{:.1f}'.format(self.ui_min_saturation),
+                       get_values=lambda: dict(
+                           ('{:.1f}'.format(value/10), lambda value=value: setattr(self, 'ui_min_saturation', value/10) or self._update_style())
+                           for value in range(0, 11)
+                       )),
+                Option(title='UI Max Saturation',
+                       description='Set the maximum saturation level for UI elements.',
+                       is_visible=lambda: getattr(self, 'show_all_options', False),
+                       get_current_value=lambda: '{:.1f}'.format(self.ui_max_saturation),
+                       get_values=lambda: dict(
+                           ('{:.1f}'.format(value/10), lambda value=value: setattr(self, 'ui_max_saturation', value/10) or self._update_style())
+                           for value in range(0, 11)
+                       )),
+                
+                # General color options
                 simple_option(title='True color (24 bit)',
                         # is_visible=lambda:getattr(self,'show_all_options',True),
-
                               description='Use 24 bit colors instead of 256 colors\nThis is only supported on some terminal apps\nSome known to support it: Ubuntu\'s default terminal, MacOS iTerm',
                               field_name='true_color'),
             ]),