This design gets cumbersome to manage, as it requires every argument to be a list of exactly 1 or exactly n elements, where n is supposed to match the length of one of those list arguments (id_value). This cannot easily account for situations where any given list contains x number of elements where x != 1 and x != n.

Further, we can certainly account for the 20 request limit specified in Amazon's documentation, but current code is not performing that check.

I think we'd be better served if each item is defined by a dictionary, like so:

fee_requests = [
    {
        'id_value': 'B082YTKC47',
        'id_type': 'ASIN',
        'marketplace': 'A1F83G8C2ARO7P',
        'is_amazon_fulfilled': True,
        'identifier': 'Fee requests',
        'listing_price': {
            'amount': 19.0,
            'currency_code': 'GBP',
        },
        'shipping': {
            'amount': 5.0,
            'currency_code': 'USD',
        },
        'points': {
            'number': 5,
            'monetary_value': {
                'amount': 2.0,
                'currency_code': 'EUR',
            },
        }
    },
    # and so on, up to 20
]

The request method should then be able to accept one of the following signatures:

# a single list argument, containing a list of dicts:
resp = products_api.get_my_fees_estimate(fee_requests=fee_requests)

# OR an arbitrary set of arguments that can be unpacked, each one being a dict:
resp = products_api.get_my_fees_estimate(*fee_requests)

I'm a little partial the second one myself, but either will do. 🤷

Note that the example also includes shipping and points, which can also be requested according to documentation (see PriceToEstimateFees in the Products Datatypes doc). Full coverage of the request's potential parameters will be necessary before the method can be accepted.

Despite the points made about the overall design, this is great documentation to explain the method's usage and options. Really appreciate having the docstring be this detailed to help me see the intended design. 👍

Minor point, an upcoming change (#207) will move the Action parameter to the signature for make_request. I recommend removing this key from data, and then at the end of the method calling:

return self.make_request("GetMyFeesEstimate", data)

As a general point, iterating using range(len(...)) is an anti-pattern. If the index is required in the loop, you're better off using enumerate():

for idx, val in enumerate(id_value):
    print(marketplace_id[idx])
    print(val)

I can see how this is attempting to use a list of values that contains either 1 or n items, where n is intended to be the same as the number of id_value elements. However, in the case that any given list is shorter than it should be, this will simply return the first element for each subsequent id_value:

id_value = [0, 1, 2, 3]
marketplace_id = ['a', 'b']

The above would create sets like (0, 'a'), (1, 'b'), (2, 'a'), (3, 'a') (the last two re-using the first element in marketplace_id). This may create an error if the data in position 0 is not meant to match up with the data in position x of any other list. Trying to account for this error means checking list length for every list before processing.

That point is moot, however, as the design becomes too cumbersome to manage with these tightly-coupled list arguments (see other comments on review).