rp 0.1.1275__tar.gz → 0.1.1276__tar.gz

{rp-0.1.1275 → rp-0.1.1276}/PKG-INFO

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

{rp-0.1.1275 → rp-0.1.1276}/rp/libs/stamp_tensor.py

@@ -198,6 +198,29 @@ def _get_proportional_offset(shape, proportions):
     
     return [-(proportion * (size - 1)) for proportion, size in zip(proportions, shape)]
 
+def _parse_tensor_shape_form(form:str):
+    """
+    'BCHW' -> ['B', 'C', 'H', 'W']
+    'B' -> ['B']
+    'B C H W' -> ['B', 'C', 'H', 'W']
+    'B VC VH VW' -> ['B', 'VC', 'VH', 'VW']
+    """
+    dims = form.split()
+    if len(dims)==1:
+        dims=dims[0].split()
+    return dims
+
+class _StampModes:
+    def add     (x,y): return x + y
+    def replace (x,y): return y
+    def subtract(x,y): return x - y
+    def multiply(x,y): return x * y
+    def divide  (x,y): return x / y
+    def max     (x,y): return rp.r._maximum(x, y)
+    def min     (x,y): return rp.r._minimum(x, y)
+    def mean    (x,y): return (x + y) / 2
+
+stamp_modes = {name : func for name, func in _StampModes.__dict__.items() if not name.startswith('_')}
 
 def stamp_tensor(canvas, sprite, offset=None, *, mutate=False, mode='add', sprite_origin=None, canvas_origin=None, interp='nearest', wrap=False):
     """
@@ -209,8 +232,8 @@ def stamp_tensor(canvas, sprite, offset=None, *, mutate=False, mode='add', sprit
         offset: Position to place the sprite. If None, defaults to origin. Can be shorter than ndim - will be padded with 0s
         mutate: If False, copy canvas before modifying. If True, modify in place.
         mode: How to combine sprite with canvas ('add' or callable)
-        sprite_origin: Proportional coordinates within sprite or named origin ('top left', 'center', etc.). Can be shorter than ndim - will be padded with 0s
-        canvas_origin: Proportional coordinates within canvas or named origin ('top left', 'center', etc.). Can be shorter than ndim - will be padded with 0s
+        sprite_origin: Proportional coordinates within sprite ([0,0], [.5,.5], etc.) or named origin ('top left', 'center', etc.). Can be shorter than ndim - will be padded with 0s
+        canvas_origin: Proportional coordinates within canvas ([0,0], [.5,.5], etc.) or named origin ('top left', 'center', etc.). Can be shorter than ndim - will be padded with 0s
         interp: Interpolation method ('nearest' or 'bilinear')
         wrap: Enable wrapping. True/False for all dims, or list of bools per dimension
                      
@@ -228,7 +251,8 @@ def stamp_tensor(canvas, sprite, offset=None, *, mutate=False, mode='add', sprit
     Works with both numpy arrays and torch tensors (or any array-like with shape attribute
     and standard indexing/arithmetic operations).
     """
-    assert canvas.ndim == sprite.ndim, "Canvas and sprite must have same number of dimensions"
+    if not canvas.ndim == sprite.ndim:
+        raise ValueError("Canvas and sprite must have same number of dimensions but canvas.shape=={0} and sprite.shape=={1}".format(canvas.shape, sprite.shape))
     
     # Default offset to origin if None
     if offset is None:
@@ -267,9 +291,9 @@ def stamp_tensor(canvas, sprite, offset=None, *, mutate=False, mode='add', sprit
     canvas_offset = _get_proportional_offset(canvas.shape, canvas_origin)
     adjusted_offset = [offset[i] + sprite_offset[i] - canvas_offset[i] for i in range(len(offset))]
     
-    # Convert 'add' to lambda function once
-    if mode == 'add':
-        mode = lambda x, y: x + y
+    # Convert 'add', 'replace' etc to lambda function once
+    if mode in stamp_modes:
+        mode = stamp_modes[mode]
     
     if any(wrap):
         return _stamp_with_wrapping(canvas, sprite, adjusted_offset, mode, wrap, interp)
@@ -282,7 +306,6 @@ def stamp_tensor(canvas, sprite, offset=None, *, mutate=False, mode='add', sprit
             _stamp_nearest(canvas, sprite, adjusted_offset, mode)
         return canvas
 
-
 def test_stamp_tensor():
     import numpy as np
     
@@ -615,8 +638,6 @@ def test_stamp_tensor():
     
     print("All tests passed!")
 
-
-
 def demo_stamp_tensor():
     import rp
 
@@ -649,8 +670,90 @@ def demo_stamp_tensor():
             )
         )
 
+def crop_tensor(tensor, crop_shape, origin=None, *, crop_offset=None, tensor_offset=None, tensor_origin=None, crop_origin=None, interp='nearest', wrap=False):
+    """
+    Crop a tensor to the specified shape using stamp_tensor's flexible origin system.
+    
+    Args:
+        tensor: Source tensor to crop from
+        crop_shape: Shape of the output cropped tensor
+        origin: Convenience parameter to set both tensor_origin and crop_origin to the same value
+        crop_offset: Position in source tensor to start cropping from. If None, defaults to [0, 0, ...]
+        tensor_offset: Position in crop output to place the tensor. If None, defaults to [0, 0, ...]
+        tensor_origin: Origin point in the source tensor ('top left', 'center', [0.5, 0.5], etc.)
+        crop_origin: Origin point in the crop output ('top left', 'center', [0.5, 0.5], etc.)
+        interp: Interpolation method ('nearest' or 'bilinear')
+        wrap: Enable wrapping behavior (True/False or list of bools per dimension)
+        
+    Returns:
+        Cropped tensor of shape crop_shape
+        
+    This leverages stamp_tensor's origin system for maximum flexibility. Two independent operations:
+    1. crop_offset slides the crop window within the source tensor (what to crop)
+    2. tensor_offset slides the source tensor within the crop output (where to place it)
+    
+    Note: If origin is specified, both tensor_origin and crop_origin will be set to it.
+          Don't specify both origin and tensor_origin/crop_origin simultaneously.
+    
+    Examples:
+        >>> import numpy as np
+        ... arr = np.ones((2, 3))
+        ... print(crop_tensor(arr, (4, 5)))  # Pad: ones in top-left 2x3, zeros elsewhere
+        ... print(crop_tensor(arr, (1, 2)))  # Crop: extract top-left 1x2 region
+        [[1. 1. 1. 0. 0.]
+         [1. 1. 1. 0. 0.]
+         [0. 0. 0. 0. 0.]
+         [0. 0. 0. 0. 0.]]
+        [[1. 1.]]
+        
+        >>> # Advanced: crop from center of large image, place at offset in output
+        ... large_img = np.arange(100).reshape(10, 10)
+        ... cropped = crop_tensor(large_img, (5, 5), crop_offset=[3, 3], tensor_offset=[1, 1])
+        [[22 23 24 25 26]
+         [32 33 34 35 36]
+         [42 43 44 45 46]
+         [52 53 54 55 56]
+         [62 63 64 65 66]]
+    """
+    import rp
+
+    # Handle origin convenience parameter
+    if origin is not None:
+        if tensor_origin is not None or crop_origin is not None:
+            raise ValueError("Don't specify both 'origin' and 'tensor_origin'/'crop_origin' simultaneously")
+        tensor_origin = origin
+        crop_origin = origin
+
+    if len(crop_shape) < tensor.ndim:
+        #In future version of stamp_tensor with broadcasting, this might not be needed
+        crop_shape = tuple(crop_shape) + tuple(tensor.shape[len(crop_shape):])
+    
+    # Create output tensor filled with zeros
+    output = rp.r._zeros_like(tensor, shape=crop_shape)
+    
+    # The key insight: we stamp the source tensor onto the crop-sized output
+    if crop_offset   is None: crop_offset   = []
+    if tensor_offset is None: tensor_offset = []
+    
+    # Pad both to same length as tensor.ndim before subtracting
+    offset_len = max(map(len, [crop_offset, tensor_offset]))
+    crop_offset   = list(crop_offset  ) + [0] * (offset_len - len(crop_offset  ))
+    tensor_offset = list(tensor_offset) + [0] * (offset_len - len(tensor_offset))
+    
+    final_offset = [t - c for t, c in zip(tensor_offset, crop_offset)]
+    
+    return stamp_tensor(
+        output, 
+        tensor, 
+        final_offset, 
+        mutate=True, 
+        mode='replace',               # Replace mode - sprite overwrites canvas
+        sprite_origin=tensor_origin,  # Where in the source tensor to anchor
+        canvas_origin=crop_origin,    # Where in the crop output to place that anchor
+        interp=interp,                # Interpolation method
+        wrap=wrap                     # Wrapping behavior
+    )
 
 if __name__ == "__main__":
     test_stamp_tensor()
 
-

{rp-0.1.1275 → rp-0.1.1276}/rp/r.py

@@ -55,7 +55,12 @@ import copy
 copy.copy.__dict__.update(copy.__dict__)
 copy = copy.copy
 
-from rp.libs.stamp_tensor import stamp_tensor
+try:
+    from rp.libs.stamp_tensor import stamp_tensor, crop_tensor
+except ImportError:
+    #Delete this post-july 2025
+    print("TODO: Update your rp. Couldnt import stamp_tensor and crop_tensor")
+
 
 _original_pwd = os.getcwd()
 
@@ -16451,7 +16456,7 @@ def _print_status(x):
 
     _print_status_prev_len = len(x)
 
-def _eta(total_n,*,min_interval=.3,title="r.eta"):
+def _eta(total_n,*,min_interval,title):
     """
     Example:
         >>> a = eta(2000,title='test')
@@ -16543,7 +16548,7 @@ class eta:
         ...     sleep(.1)
     """
 
-    def __init__(self, x, title='r.eta', min_interval=.3, length=None):
+    def __init__(self, x, title='r.eta', min_interval=.05, length=None):
         assert isinstance(x, int) or hasattr(x, '__len__') or length is not None
 
         if length is not None:
@@ -17610,6 +17615,14 @@ def _delete_pyin_settings_file():
 
 def _set_session_title(title=None):
     pyin=_globa_pyin[0]
+    if pyin is None:
+        #So we can do: rp exec "pterm(level_title='cheese')"
+        @run_as_new_thread
+        def do_when_ready():
+            while _globa_pyin[0] is None:
+                sleep(.1)
+            _set_session_title(title)
+        return
     if title is None:
         if hasattr(pyin,'session_title'):
             current_title=pyin.session_title
@@ -22550,11 +22563,11 @@ def pseudo_terminal(
                             # fansi_print(user_message,"yellow")
                             print(fansi_syntax_highlighting(user_message))
                         elif user_message.startswith("RANT ") or user_message.startswith("RANT\n"):
-                            user_message="run_as_new_thread(exec,"+repr(user_message[5:].strip())+",globals(),locals())"
+                            user_message="__import__('rp').run_as_new_thread(exec,"+repr(user_message[5:].strip())+",globals(),locals())"
                         elif user_message=='RANT':
-                            user_message="run_as_new_thread(exec,"+repr(get_ans())+",globals(),locals());"
+                            user_message="__import__('rp').run_as_new_thread(exec,"+repr(get_ans())+",globals(),locals());"
                         elif user_message.startswith("RANP "):
-                            user_message="run_as_new_process(exec,"+repr(user_message[5:].strip())+",globals(),locals())"
+                            user_message="__import__('rp').run_as_new_process(exec,"+repr(user_message[5:].strip())+",globals(),locals())"
                         elif user_message=='VPASTE':
                             fansi_print("VPASTE --> Vim Paste","blue",'bold')
                             tmux_clipboard=vim_paste()
@@ -25773,6 +25786,57 @@ def cv_manually_selected_contour(contours,image=None):
         if done:
             return selected_contour
 
+def cv_distance_transform(mask, distance_to='white', metric='l2', algorithm='precise', ):
+    """
+    Compute distance transform using OpenCV.
+    
+    Args:
+        mask: 2D boolean array
+        distance_to: What are we returning distances to? Options:
+            - 'white': Regions where mask==True
+            - 'black': Regions where mask==False
+        metric: Distance metric. Options:
+            - 'l1': Manhattan distance (cv2.DIST_L1)
+            - 'l2': Euclidean distance (cv2.DIST_L2) 
+            - 'c': Chessboard distance (cv2.DIST_C)
+        algorithm: Algorithm precision. Options:
+            - 'precise': Exact Euclidean (Felzenszwalb algorithm, slowest)
+            - '3': Fast 3x3 mask (Borgefors algorithm)
+            - '5': Better 5x5 mask with knight's moves
+    """
+    pip_import('cv2')
+
+    import cv2
+    
+    mask=as_grayscale_image(mask)
+    mask=as_byte_image(as_binary_image(mask))
+
+    #Are we retuning the distance to white areas or black areas?
+    if distance_to=='white':
+        mask = inverted_image(mask)
+    elif distance_to=='black':
+        pass
+    else:
+        raise ValueError('cv_distance_transform: distance_to should be either "white" or "black" but got %s'%distance_to)
+
+    metric_map = {
+        'l1': cv2.DIST_L1,
+        'l2': cv2.DIST_L2, 
+        'c': cv2.DIST_C
+    }
+    
+    mask_map = {
+        '3': cv2.DIST_MASK_3,
+        '5': cv2.DIST_MASK_5,
+        'precise': cv2.DIST_MASK_PRECISE
+    }
+    
+    distances = cv2.distanceTransform(mask, metric_map[metric], mask_map[algorithm])
+    
+    assert distances.shape==mask.shape
+    return distances
+
+
 def cosine_similarity(x,y):
     return np.sum(normalized(x)*normalized(y).conj())
 
@@ -32062,7 +32126,7 @@ def download_youtube_video(url_or_id: str,
         preferred_resolution=resolution_preference(resolutions) #Choosing the best resoltion
         best_resolution=str(max(resolutions))+'p' # Like "720p"
         #
-        ys = ys.filter(resolution=best_resolution).get_highest_resolution()
+        ys = ys.filter(resolution=best_resolution).get_highest_resolution(progressive=False)
         print(ys)
     else:
         ys = yt.streams.filter(mime_type='audio/'+filetype).get_audio_only()
@@ -38762,18 +38826,30 @@ def get_port_is_taken(port: int) -> bool:
             return False
 
 
-def get_next_free_port(port):
+def get_next_free_port(port,n=0):
     """
     Find the next free port starting from a given port.
     For example, if port=8080 and port 8080 is taken, it tries port 8081.
     And if that's taken, tries port 8082 until it finds some free, unused port.
+    
+    Args:
+        port (int): Starting port number to check
+        n (int): Number of additional free ports to skip (default: 0)
+                If n=1, returns the second free port found
+                If n=2, returns the third free port found, etc.
     """
+    
+    if n:
+        for _ in range(n):
+            port=get_next_free_port(port)
+            port+=1
 
     assert isinstance(port, int)
     while get_port_is_taken(port):
         port+=1
     return port
 
+
 _get_all_taken_ports_cache = None
 
 
@@ -39093,20 +39169,15 @@ def tmux_close_other_windows():
 def tmux_close_other_sessions():
     """Closes all tmux sessions except the current one."""
     current_session = tmux_get_current_session_name()
-    all_sessions = _get_all_tmux_sessions()
+    all_sessions = tmux_get_all_session_names()
     sessions_to_close = [s for s in all_sessions if s != current_session]
 
     # Close each session
     for session in sessions_to_close:
-        _run_tmux_command(['tmux', 'kill-session', '-t', session])
+        tmux_kill_session(session)
 
 tmux_kill_other_sessions = tmux_close_other_sessions
 
-def _get_all_tmux_sessions():
-    """Returns a list of all session names in tmux."""
-    sessions = _run_tmux_command(['tmux', 'list-sessions', '-F', '#{session_name}']).split()
-    return list(sessions)
-
 def tmux_detach_other_clients():
     """Detaches all other clients from the current tmux session."""
     current_session = tmux_get_current_session_name()
@@ -42976,6 +43047,8 @@ def _create_array_like(x, *, func_name, shape=None, dtype=None):
             return th.ones(target_shape, dtype=target_dtype, device=device)
         elif func_name == 'randn':
             return th.randn(target_shape, dtype=target_dtype, device=device)
+        elif func_name == 'rand':
+            return th.rand(target_shape, dtype=target_dtype, device=device)
     elif is_numpy_array(x):  # NumPy array
         import numpy as np
         if func_name == 'zeros':
@@ -42984,6 +43057,8 @@ def _create_array_like(x, *, func_name, shape=None, dtype=None):
             return np.ones(target_shape, dtype=target_dtype)
         elif func_name == 'randn':
             return np.random.randn(*target_shape).astype(target_dtype)
+        elif func_name == 'rand':
+            return np.random.rand(*target_shape).astype(target_dtype)
     else:
         assert False, type(x)
             
@@ -43003,49 +43078,109 @@ def _randn_like(x, *, shape=None, dtype=None):
     """Works across libraries - such as numpy, torch"""
     return _create_array_like(x, func_name='randn', shape=shape, dtype=dtype)
 
-def crop_tensor(tensor, new_shape):
-    """
-    Crop or pad tensor to new shape, preserving original data where dimensions overlap.
-    
-    Creates a new tensor/array with the requested shape and copies data from
-    the original tensor where dimensions overlap. Works with both NumPy arrays
-    and PyTorch tensors. Can make tensors larger (padding with zeros) or smaller (cropping).
-    
-    Args:
-        tensor: Input tensor (PyTorch) or array (NumPy)
-        new_shape: Target shape as tuple of dimensions
-        
-    Returns:
-        New tensor/array with requested shape containing original data
-        where dimensions overlap
+def _rand_like(x, *, shape=None, dtype=None):
+    """Works across libraries - such as numpy, torch"""
+    return _create_array_like(x, func_name='rand', shape=shape, dtype=dtype)
 
-    Examples:
-        >>> import numpy as np
-        ... arr = np.ones((2, 3))
-        ... print(crop_tensor(arr, (4, 5)))  # returns array of shape (4, 5) with ones in top-left 2x3 area
-        ... print(crop_tensor(arr, (1, 2)))  # returns array of shape (1, 2) with data cropped from original
-        [[1. 1. 1. 0. 0.]
-         [1. 1. 1. 0. 0.]
-         [0. 0. 0. 0. 0.]
-         [0. 0. 0. 0. 0.]]
-        [[1. 1.]]
-        
-        >>> import torch
-        ... t = torch.ones((2, 3))
-        ... print(crop_tensor(t, (4, 5)))  # returns tensor of shape (4, 5) with ones in top-left 2x3 area
-        ... print(crop_tensor(t, (1, 2))  # returns tensor of shape (1, 2) with data cropped from original
-        tensor([[1., 1., 1., 0., 0.],
-                [1., 1., 1., 0., 0.],
-                [0., 0., 0., 0., 0.],
-                [0., 0., 0., 0., 0.]])
-        tensor([[1., 1.]])
-
-    """
-    old_shape = tensor.shape
-    new_tensor = _zeros_like(tensor, shape=new_shape)
-    slices = tuple(slice(0, min(o, n)) for o, n in zip(old_shape, new_shape))
-    new_tensor[slices] = tensor[slices]
-    return new_tensor
+def _maximum(x, y):
+    """ works across libraries - such as numpy, torch """
+    if is_numpy_array (x):return np.maximum(x, y)
+    if is_torch_tensor(x):return __import__('torch').maximum(x, y)
+    raise ValueError("type not supported: "+str(type(x)))
+
+def _minimum(x, y):
+    """ works across libraries - such as numpy, torch """
+    if is_numpy_array (x):return np.minimum(x, y)
+    if is_torch_tensor(x):return __import__('torch').minimum(x, y)
+    raise ValueError("type not supported: "+str(type(x)))
+
+def _max(x, dim=None, keepdim=False):
+    """ works across libraries - such as numpy, torch """
+    if is_numpy_array (x):return np.max(x, axis=dim, keepdims=keepdim)
+    if is_torch_tensor(x):
+        if dim is None:return __import__('torch').max(x)
+        result = __import__('torch').max(x, dim=dim, keepdim=keepdim)
+        return result.values if hasattr(result, 'values') else result
+    if dim is None:return max(x) if hasattr(x, '__iter__') else x
+    raise ValueError("type not supported: "+str(type(x)))
+
+def _min(x, dim=None, keepdim=False):
+    """ works across libraries - such as numpy, torch """
+    if is_numpy_array (x):return np.min(x, axis=dim, keepdims=keepdim)
+    if is_torch_tensor(x):
+        if dim is None:return __import__('torch').min(x)
+        result = __import__('torch').min(x, dim=dim, keepdim=keepdim)
+        return result.values if hasattr(result, 'values') else result
+    if dim is None:return min(x) if hasattr(x, '__iter__') else x
+    raise ValueError("type not supported: "+str(type(x)))
+
+def _sum(x, dim=None, keepdim=False):
+    """ works across libraries - such as numpy, torch """
+    if is_numpy_array (x):return np.sum(x, axis=dim, keepdims=keepdim)
+    if is_torch_tensor(x):return __import__('torch').sum(x, dim=dim, keepdim=keepdim)
+    if dim is None:return sum(x) if hasattr(x, '__iter__') else x
+    raise ValueError("type not supported: "+str(type(x)))
+
+def _mean(x, dim=None, keepdim=False):
+    """ works across libraries - such as numpy, torch """
+    if is_numpy_array (x):return np.mean(x, axis=dim, keepdims=keepdim)
+    if is_torch_tensor(x):return __import__('torch').mean(x, dim=dim, keepdim=keepdim)
+    raise ValueError("type not supported: "+str(type(x)))
+
+#NOT Doing std, np and torch behave differently (one has N-1 correction [torch], the other doesn'ti [numpy])
+# def _std(x, dim=None, keepdim=False):
+#     """ works across libraries - such as numpy, torch, pure python """
+#     if is_numpy_array (x):return np.std(x, axis=dim, keepdims=keepdim)
+#     if is_torch_tensor(x):return __import__('torch').std(x, dim=dim, keepdim=keepdim)
+#     if dim is None:
+#         import statistics
+#         return statistics.stdev(x) if hasattr(x, '__iter__') and len(x) > 1 else 0
+#     raise ValueError("dim parameter not supported for Python scalars")
+
+
+# def crop_tensor(tensor, new_shape):
+#     """
+#     Crop or pad tensor to new shape, preserving original data where dimensions overlap.
+#
+#     Creates a new tensor/array with the requested shape and copies data from
+#     the original tensor where dimensions overlap. Works with both NumPy arrays
+#     and PyTorch tensors. Can make tensors larger (padding with zeros) or smaller (cropping).
+#
+#     Args:
+#         tensor: Input tensor (PyTorch) or array (NumPy)
+#         new_shape: Target shape as tuple of dimensions
+#
+#     Returns:
+#         New tensor/array with requested shape containing original data
+#         where dimensions overlap
+#
+#     Examples:
+#         >>> import numpy as np
+#         ... arr = np.ones((2, 3))
+#         ... print(crop_tensor(arr, (4, 5)))  # returns array of shape (4, 5) with ones in top-left 2x3 area
+#         ... print(crop_tensor(arr, (1, 2)))  # returns array of shape (1, 2) with data cropped from original
+#         [[1. 1. 1. 0. 0.]
+#          [1. 1. 1. 0. 0.]
+#          [0. 0. 0. 0. 0.]
+#          [0. 0. 0. 0. 0.]]
+#         [[1. 1.]]
+#
+#         >>> import torch
+#         ... t = torch.ones((2, 3))
+#         ... print(crop_tensor(t, (4, 5)))  # returns tensor of shape (4, 5) with ones in top-left 2x3 area
+#         ... print(crop_tensor(t, (1, 2))  # returns tensor of shape (1, 2) with data cropped from original
+#         tensor([[1., 1., 1., 0., 0.],
+#                 [1., 1., 1., 0., 0.],
+#                 [0., 0., 0., 0., 0.],
+#                 [0., 0., 0., 0., 0.]])
+#         tensor([[1., 1.]])
+#
+#     """
+#     old_shape = tensor.shape
+#     new_tensor = _zeros_like(tensor, shape=new_shape)
+#     slices = tuple(slice(0, min(o, n)) for o, n in zip(old_shape, new_shape))
+#     new_tensor[slices] = tensor[slices]
+#     return new_tensor
 
 
 def get_bilinear_weights(x, y):

rp-0.1.1276/rp/version.py

@@ -0,0 +1 @@
+1276