Optional address indexing in ModbusDeviceContext

[embedded-bed]

The getValues and setValues methods in the ModbusDeviceContext class increments the address by 1:

    def getValues(self, func_code, address, count=1) -> list[int] | list[bool] | ExcCodes:
        """Get `count` values from datastore.

        :param func_code: The function we are working with
        :param address: The starting address
        :param count: The number of values to retrieve
        :returns: The requested values from a:a+c
        """
        address += 1
        Log.debug("getValues: fc-[{}] address-{}: count-{}", func_code, address, count)
        return self.store[self.decode(func_code)].getValues(address, count)

    def setValues(self, func_code, address, values) -> None | ExcCodes:
        """Set the datastore with the supplied values.

        :param func_code: The function we are working with
        :param address: The starting address
        :param values: The new values to be set
        """
        address += 1
        Log.debug("setValues[{}] address-{}: count-{}", func_code, address, len(values))
        return self.store[self.decode(func_code)].setValues(address, values)

However, this can be troublesome to deal with in the case where the user wants a server with starting register address of 0. Should the client then request the address -1 from the server, since it's incremented internally?
Zero indexing is not uncommon in applications, and providing the option to control the addressing in Pymodbus would be a nice feature.

One proposal could be an optional argument when creating a ModbusDeviceContext object:

class ModbusDeviceContext(ModbusBaseDeviceContext):
    """
    :param di: discrete inputs initializer ModbusDataBlock
    :param co: coils initializer ModbusDataBlock
    :param hr: holding register initializer ModbusDataBlock
    :param ir: input registers initializer ModbusDataBlock
    :param address_offset: integer added to the requested address before accessing the block.
    """

    def __init__(self, *_args,
                 di: BaseModbusDataBlock | None = None,
                 co: BaseModbusDataBlock | None = None,
                 ir: BaseModbusDataBlock | None = None,
                 hr: BaseModbusDataBlock | None = None,
                 address_offset: int = 1):
        super().__init__()
        self.store = {
            self.DI: di or ModbusSequentialDataBlock(0, [0]*1),
            self.CO: co or ModbusSequentialDataBlock(0, [0]*1),
            self.IR: ir or ModbusSequentialDataBlock(0, [0]*1),
            self.HR: hr or ModbusSequentialDataBlock(0, [0]*1),
        }
        address_offset = int(address_offset)
        if address_offset not in (0, 1):
            raise ValueError(f"address offset {address_offset} is invalid; must be 0 or 1")
        self.address_offset = int(address_offset)

And then in the methods:

    def getValues(self, func_code, address, count=1) -> list[int] | list[bool] | ExcCodes:
        """Get `count` values from datastore.

        :param func_code: The function we are working with
        :param address: The starting address
        :param count: The number of values to retrieve
        :returns: The requested values from a:a+c
        """
        address += self.address_offset
        Log.debug("getValues: fc-[{}] address-{}: count-{}", func_code, address, count)
        return self.store[self.decode(func_code)].getValues(address, count)

    def setValues(self, func_code, address, values) -> None | ExcCodes:
        """Set the datastore with the supplied values.

        :param func_code: The function we are working with
        :param address: The starting address
        :param values: The new values to be set
        """
        address += self.address_offset
        Log.debug("setValues[{}] address-{}: count-{}", func_code, address, len(values))
        return self.store[self.decode(func_code)].setValues(address, values)

Let me know if this is a desired feature or not. I am not sure how you want to handle invalid address offset, right now I just raise a ValueError as an example.
I can create the PR as well, if you would like.

[janiversen]

You are mixing the definition of data and the requests.

Data are defined from 1 and upwards, which corresponds to requests from 0 and upwards.

If a request comes with address 0, the += 1 means it is addressed internally as 1, I have no idea how you would request address -1, and also not why.