Computing a list of divisors of a number
You code is hard to understand. Very hard.

In Python we prefer iteration over recursion, not only does recursion limit you to a maximum depth of 1000 function calls, it also has severe performance impacts.

You should:


Use snake_case in Python not camelCase. The only time you use CamelCase is when creating a class.
Start using generators. In most cases you can just replace list.append with a yield.
Change nthPrime to be a generator, say primes. As I'm not here to re-write nthPrime you can just use itertools.count to get an infinite generator.
Don't duplicate logic before and during a loop. In prime_factorization, you wrote the floor division, n //= prime, twice.
It's simpler to use a for loop and break from it, than while looping with a condition and manually taking the next item.
You can use collections.namedtuple to remove the need to create your own class.


Merging the above together for just prime_factorization can get you:

from collections import namedtuple
from itertools import count

Option = namedtuple('Option', 'value count')


def primes():
    for i in count():
        yield nthPrime(i)


def prime_factorization(n):
    for prime in primes():
        count = 0
        while n % prime == 0:
            count += 1
            n //= prime
        if count:
            yield Option(prime, count)
        if n &lt;= 1:
            break


After this you want to move more code into combinations, so that it's self contained in getCombinationsIncrement, and to rename it combinations.


Change combinations to instead yield a tuple of chosen.
Create chosen within combinations.
Pass a single one dimensional list to combinations so that it's more usable later.
When you finish running through all of options without yielding, you want to stop. To do this you can use the for ... else syntax and just break.


This should be able to get you:

def combinations(options):
    chosen = [0] * len(options)
    while True:
        for i, option in enumerate(options):
            chosen[i] += 1
            if chosen[i] &gt; option:
                chosen[i] = 0
                break
            yield tuple(chosen)
        else:
            break


Finally we want to change combinations_reduce to use combinations.


First you should change options from a 2d lists to two 1d lists. You should want to get values and counts into their own lists. And so you can use zip with the argument unpacking operator, *, to expand the list to \$n\$ 2 long lists.
You want to create combos off the bat, and can use enumerate to get the current index.

Alternately you could try using yield instead, and off-load the sorting to the user.
You can use reduce to replace your innermost loop.
You can change the input to use default variables of operators.mul and 1. This simplifies the usage, as you don't need to specify as much.


This can get you:

def combinations_reduced(options, combine=mul, base=1):
    values, counts = zip(*options)
    combos = [base] * len(counts)
    for i, chosen in enumerate(combinations(counts), 1):
        for j, value in enumerate(values):
            combos[i] = reduce(combine, [combos[i]] + [value] * chosen[j])
    combos.sort()
    return combos


def get_divisors(n):
    return combinations_reduced(prime_factorization(n))