Renumbering cues

FYI. You can renumber cues by Moving them with [Cue] X [Move To] Y. This can also be used in conjunction with [Cue Only].

Something like the Hog4 can do

Yes, totally agree with you mathilda, I guess having an {Increment} SoftKey attribute of Cue X [Move To] Y [Increment] Z would be a good way for ETC to implement something like that on EOS...

Example Cue 1 Thru Thru 10 Move To Cue 1 Increment 1

Changing Cue 1,  1.1,  1.2,  2,  4,  5,  7,  10    into...

Cue 1, 2, 3, 4, 5, 6, 7, 8

Or another example: Preset 1 Thru Thru 10 Move To Preset 1 Increment 0.1

Changing Preset 1,  1.1,  1.2,  2,  4,  5,  7,  10    into...

Preset 1,  1.1,  1.2,  1.3,  1.4,  1.5,  1.6,  1.7

i could also think of a softkey {renumber}

And it could be used like [Cue] 1 [Thru] {Renumber} 100 {Offset} 10
-This would renumber All my Cues, starting from 1 till the end.
-Start the new Cues with 100 and make a Gap of 10 inbetween every following Cue (100,110,120,...)

Or just use:
- [Cue] 1 [/] {Renumber}
- [Cue] 5 [Thru] 19 {Renumber}

Using the offset key would seem to be consistent with how you can create numberings ...

So [Cue] 1 [thru] 10 [Move to] 1 [Offset] 5 

Changing 1, 2, 3, 4
To become 1, 5, 10, 15, 20

Of course, the question would be how you would want point-cues to be renumbered, such that would the point cues remain in place under the main cue, unless explicitly indicated?

Getting rid of point cues is the main goal here. Using the offset key seems like a good idea if you want to get rid of the point cues, not using the key would then keep them in place. 

So [Cue] 1 [thru] 2 [Move to] 1 [Offset] 1 [Enter]

Changing 1, 1.2, 1.5, 2

To become 1, 2, 3, 4

And [Cue] 1 [thru] 2 [Moven to] 10 [Enter]

Changing 1, 1.2, 1.5, 2

To become 10, 10.2, 10.5,12

The one at the bottom does that:

import time
import socket

OSC_IP_ADDRESS = "192.168.1.9"
OSC_PORT = 8000


def send_udp(osc_addr, addr, port, string):
    def pad(data):
        return data + b"\0" * (4 - (len(data) % 4 or 4))

    if not osc_addr.startswith("/"):
        osc_addr = "/" + osc_addr

    osc_addr = osc_addr.encode() + b"\0"
    string = string.encode() + b"\0"
    tag = ",s".encode()

    message = b"".join(map(pad, (osc_addr, tag, string)))
    try:
        sock.sendto(message, (addr, port))

    except Exception:
        import traceback
        traceback.print_exc()

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)


def lighting_command(command):
    print(f"Command: {command}")
    send_udp("eos/newcmd", OSC_IP_ADDRESS, OSC_PORT, command)


def expand_integer_cues(current_cue_list, new_cue_list, start_cue, end_cue, factor):
    for i in range(start_cue, end_cue):
        lighting_command(f"Cue {current_cue_list} / {i} Copy_To Cue {new_cue_list} / {i*factor} Enter Enter")
        time.sleep(.3) # Give Eos time to keep up
        
        
def expand_decimal_cues_root_only(current_cue_list, new_cue_list, start_cue, end_cue, root_factor, floating_point_depth=0.1, multiply=False):
    '''Increment the root only, operating adding or multiplying with root_factor.'''
    i = float(start_cue)
    end_cue = float(end_cue)

    while i <= end_cue + (floating_point_depth / 10):
        root = int(i)
        decimal = i - root

        if multiply:
            boosted_root = root * root_factor
        else:
            boosted_root = root + root_factor
            
        new_cue = boosted_root + decimal

        def format_cue(n):
            return str(int(n)) if n == int(n) else str(round(n, 3))

        lighting_command(
            f"Cue {current_cue_list} / {format_cue(i)} Copy_To Cue {new_cue_list} / {format_cue(new_cue)} Enter Enter"
        )

        time.sleep(0.3)
        i += floating_point_depth
        
        
def move_cue_block(current_cue_list, new_cue_list, start_cue, end_cue, floating_point_depth=0.1, new_start_root=3):
    """
    Move a block of cues while preserving spacing, root structure, and decimal parts.
    Root is incremented each time the original root increases.
    """
    i = float(start_cue)
    end_cue = float(end_cue)
    epsilon = floating_point_depth / 100

    original_root = int(i)
    current_new_root = new_start_root

    while round(i - end_cue, 10) <= epsilon:
        this_root = int(i)
        decimal = i - this_root

        # If we've moved into a new root in the source cues, increment target root
        if this_root > original_root:
            current_new_root += (this_root - original_root)
            original_root = this_root

        new_cue = current_new_root + decimal

        def format_cue(n):
            return str(int(n)) if n == int(n) else str(round(n, 3))

        lighting_command(
            f"Cue {current_cue_list} / {format_cue(i)} Copy_To Cue {new_cue_list} / {format_cue(new_cue)} Enter Enter"
        )

        time.sleep(0.3)
        i += floating_point_depth
        
        
def collapse_cues_to_whole_numbers(current_cue_list, new_cue_list, start_cue, end_cue, new_start=1.0, step=0.1):
    """Collapse all cues (including point cues) in a range into a clean whole-number sequence.
    Equivalent to: [Cue] x [Thru] y [Move To] z [Offset] 1"""

    i = float(start_cue)
    end_cue = float(end_cue)
    epsilon = step / 100

    current_number = int(new_start)

    while round(i - end_cue, 10) <= epsilon:
        def format_cue(n):
            return str(int(n)) if n == int(n) else str(round(n, 3))

        lighting_command(
            f"Cue {current_cue_list} / {format_cue(i)} Copy_To Cue {new_cue_list} / {current_number} Enter Enter"
        )
        time.sleep(0.3)
        i += step
        current_number += 1

        
#expand_integer_cues(1, 2, 1, 100, 10)
#expand_decimal_cues_root_only(3, 4, 1.1, 2.5, 10, multiply=False)
#move_cue_block(3, 4, 1.1, 2.5, new_start_root=3)
collapse_cues_to_whole_numbers(3, 4, 1.1, 2.5, new_start=10)

But you have all kinds of tools there that fill basically every gap left by Eos that I've seen reported just now. This is a very solvable coding problem, even from the outside.

The one at the bottom does that:

import time
import socket

OSC_IP_ADDRESS = "192.168.1.9"
OSC_PORT = 8000


def send_udp(osc_addr, addr, port, string):
    def pad(data):
        return data + b"\0" * (4 - (len(data) % 4 or 4))

    if not osc_addr.startswith("/"):
        osc_addr = "/" + osc_addr

    osc_addr = osc_addr.encode() + b"\0"
    string = string.encode() + b"\0"
    tag = ",s".encode()

    message = b"".join(map(pad, (osc_addr, tag, string)))
    try:
        sock.sendto(message, (addr, port))

    except Exception:
        import traceback
        traceback.print_exc()

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)


def lighting_command(command):
    print(f"Command: {command}")
    send_udp("eos/newcmd", OSC_IP_ADDRESS, OSC_PORT, command)


def expand_integer_cues(current_cue_list, new_cue_list, start_cue, end_cue, factor):
    for i in range(start_cue, end_cue):
        lighting_command(f"Cue {current_cue_list} / {i} Copy_To Cue {new_cue_list} / {i*factor} Enter Enter")
        time.sleep(.3) # Give Eos time to keep up
        
        
def expand_decimal_cues_root_only(current_cue_list, new_cue_list, start_cue, end_cue, root_factor, floating_point_depth=0.1, multiply=False):
    '''Increment the root only, operating adding or multiplying with root_factor.'''
    i = float(start_cue)
    end_cue = float(end_cue)

    while i <= end_cue + (floating_point_depth / 10):
        root = int(i)
        decimal = i - root

        if multiply:
            boosted_root = root * root_factor
        else:
            boosted_root = root + root_factor
            
        new_cue = boosted_root + decimal

        def format_cue(n):
            return str(int(n)) if n == int(n) else str(round(n, 3))

        lighting_command(
            f"Cue {current_cue_list} / {format_cue(i)} Copy_To Cue {new_cue_list} / {format_cue(new_cue)} Enter Enter"
        )

        time.sleep(0.3)
        i += floating_point_depth
        
        
def move_cue_block(current_cue_list, new_cue_list, start_cue, end_cue, floating_point_depth=0.1, new_start_root=3):
    """
    Move a block of cues while preserving spacing, root structure, and decimal parts.
    Root is incremented each time the original root increases.
    """
    i = float(start_cue)
    end_cue = float(end_cue)
    epsilon = floating_point_depth / 100

    original_root = int(i)
    current_new_root = new_start_root

    while round(i - end_cue, 10) <= epsilon:
        this_root = int(i)
        decimal = i - this_root

        # If we've moved into a new root in the source cues, increment target root
        if this_root > original_root:
            current_new_root += (this_root - original_root)
            original_root = this_root

        new_cue = current_new_root + decimal

        def format_cue(n):
            return str(int(n)) if n == int(n) else str(round(n, 3))

        lighting_command(
            f"Cue {current_cue_list} / {format_cue(i)} Copy_To Cue {new_cue_list} / {format_cue(new_cue)} Enter Enter"
        )

        time.sleep(0.3)
        i += floating_point_depth
        
        
def collapse_cues_to_whole_numbers(current_cue_list, new_cue_list, start_cue, end_cue, new_start=1.0, step=0.1):
    """Collapse all cues (including point cues) in a range into a clean whole-number sequence.
    Equivalent to: [Cue] x [Thru] y [Move To] z [Offset] 1"""

    i = float(start_cue)
    end_cue = float(end_cue)
    epsilon = step / 100

    current_number = int(new_start)

    while round(i - end_cue, 10) <= epsilon:
        def format_cue(n):
            return str(int(n)) if n == int(n) else str(round(n, 3))

        lighting_command(
            f"Cue {current_cue_list} / {format_cue(i)} Copy_To Cue {new_cue_list} / {current_number} Enter Enter"
        )
        time.sleep(0.3)
        i += step
        current_number += 1

        
#expand_integer_cues(1, 2, 1, 100, 10)
#expand_decimal_cues_root_only(3, 4, 1.1, 2.5, 10, multiply=False)
#move_cue_block(3, 4, 1.1, 2.5, new_start_root=3)
collapse_cues_to_whole_numbers(3, 4, 1.1, 2.5, new_start=10)

But you have all kinds of tools there that fill basically every gap left by Eos that I've seen reported just now. This is a very solvable coding problem, even from the outside.