def get_addresses(self, start, count=1, step=1):
        # type: (int, int, int) -> List[Address]
        """
        Generates and returns one or more addresses at the specified
        index(es).

        This is a one-time operation; if you want to create lots of
        addresses across multiple contexts, consider invoking
        :py:meth:`create_iterator` and sharing the resulting generator
        object instead.

        Warning: This method may take awhile to run if the starting
        index and/or the number of requested addresses is a large
        number!

        :param start:
            Starting index.
            Must be >= 0.

        :param count:
            Number of addresses to generate.
            Must be > 0.

        :param step:
            Number of indexes to advance after each address.
            This may be any non-zero (positive or negative) integer.

        :return:
            Always returns a list, even if only one address is generated.

            The returned list will contain ``count`` addresses, except
            when ``step * count < start`` (only applies when ``step`` is
            negative).
        """
        if count < 1:
            raise with_context(
                exc=ValueError('``count`` must be positive.'),

                context={
                    'start': start,
                    'count': count,
                    'step': step,
                },
            )

        if not step:
            raise with_context(
                exc=ValueError('``step`` must not be zero.'),

                context={
                    'start': start,
                    'count': count,
                    'step': step,
                },
            )

        generator = self.create_iterator(start, step)

        addresses = []
        for _ in range(count):
            try:
                next_addy = next(generator)
            except StopIteration:
                break
            else:
                addresses.append(next_addy)

        return addresses
def get_addresses(self, start, count=1, step=1):
        # type: (int, int, int) -> List[Address]
        """
        Generates and returns one or more addresses at the specified
        index(es).

        This is a one-time operation; if you want to create lots of
        addresses across multiple contexts, consider invoking
        :py:meth:`create_iterator` and sharing the resulting generator
        object instead.

        Warning: This method may take awhile to run if the starting
        index and/or the number of requested addresses is a large
        number!

        :param start:
            Starting index.
            Must be >= 0.

        :param count:
            Number of addresses to generate.
            Must be > 0.

        :param step:
            Number of indexes to advance after each address.
            This may be any non-zero (positive or negative) integer.

        :return:
            Always returns a list, even if only one address is generated.

            The returned list will contain ``count`` addresses, except
            when ``step * count < start`` (only applies when ``step`` is
            negative).
        """
        if count < 1:
            raise with_context(
                exc=ValueError('``count`` must be positive.'),

                context={
                    'start': start,
                    'count': count,
                    'step': step,
                },
            )

        if not step:
            raise with_context(
                exc=ValueError('``step`` must not be zero.'),

                context={
                    'start': start,
                    'count': count,
                    'step': step,
                },
            )

        generator = self.create_iterator(start, step)

        addresses = []
        for _ in range(count):
            try:
                next_addy = next(generator)
            except StopIteration:
                break
            else:
                addresses.append(next_addy)

        return addresses
def get_addresses ( self , start , count = 1 , step = 1 ) : # type: (int, int, int) -> List[Address] if count < 1 : raise with_context ( exc = ValueError ( '``count`` must be positive.' ) , context = { 'start' : start , 'count' : count , 'step' : step , } , ) if not step : raise with_context ( exc = ValueError ( '``step`` must not be zero.' ) , context = { 'start' : start , 'count' : count , 'step' : step , } , ) generator = self . create_iterator ( start , step ) addresses = [ ] for _ in range ( count ) : try : next_addy = next ( generator ) except StopIteration : break else : addresses . append ( next_addy ) return addresses
Generates and returns one or more addresses at the specified
        index(es).

        This is a one-time operation; if you want to create lots of
        addresses across multiple contexts, consider invoking
        :py:meth:`create_iterator` and sharing the resulting generator
        object instead.

        Warning: This method may take awhile to run if the starting
        index and/or the number of requested addresses is a large
        number!

        :param start:
            Starting index.
            Must be >= 0.

        :param count:
            Number of addresses to generate.
            Must be > 0.

        :param step:
            Number of indexes to advance after each address.
            This may be any non-zero (positive or negative) integer.

        :return:
            Always returns a list, even if only one address is generated.

            The returned list will contain ``count`` addresses, except
            when ``step * count < start`` (only applies when ``step`` is
            negative).
Generates and returns one or more addresses at the specified index ( es ) .