class FizzBuzz(object):

    def start(self, end_number):
        return ",".join(self._parse_numbers(end_number))

    def _parse_numbers(self, end_number):
        number_list = []
        for number in range(1, end_number+1):
            number_list.append(self.parse_number(number))
        return number_list

    def parse_number(self, number):
        if self._is_number_divisible_by_five_and_three(number):
            return "FizzBuzz"
        elif self._is_number_divisible_by_three(number):
            return "Fizz"
        elif self._is_number_divisible_by_five(number):
            return "Buzz"
        else:
            return str(number)

    def _is_number_divisible_by_five_and_three(self, number):
        return number % 15 == 0

    def _is_number_divisible_by_three(self, number):
        return number % 3 == 0

    def _is_number_divisible_by_five(self, number):
        return number % 5 == 0

def parse_number(number):
    if number % 15 == 0:
        return "FizzBuzz"
    elif number % 3 == 0:
        return "Fizz"
    elif number % 5 == 0:
        return "Buzz"
    else:
        return str(number)

def parse_number(number):
    """Returns a string Fizzbuzz representation of a number"""

    # This is the same as (number % 5 == 0) and (number % 3 == 0)
    if number % 15 == 0:

def parse_number(number):
    """Returns a string Fizzbuzz representation of a number"""

    # This is the same as (number % 5 == 0) and (number % 3 == 0)
    if number % 15 == 0:
        return "FizzBuzz"
    elif number % 3 == 0:
        return "Fizz"
    elif number % 5 == 0:
        return "Buzz"
    else:
        return str(number)

def fizzbuzz(end_number):
    """Return a list of Fizzbuzz parsed numbers up to end_number."""

    return [parse_number(number) for number in range(1, end_number+1)]

def fizzbuzz_string(end_number):
    return ",".join(fizzbuzz(end_number))

def is_divisible(number, modulo):
    """Return if number % modulo is equal to 0."""

    return number % modulo == 0

from collections import namedtuple

def is_divisible(number, modulo):
    """Return if number % modulo is equal to 0."""

    return number % modulo == 0


FizzBuzz = namedtuple('FizzBuzz', 'number, name')

fizz_buzz_words = [
    FizzBuzz( 3, 'Fizz'),
    FizzBuzz( 4, 'Buzz'),
    FizzBuzz( 7, 'Bang'),
    FizzBuzz(11, 'Boom'),
  ]

def to_fizz_buzz_string(n):
    """Returns an extended FizzBuzz string representation of a number."""
    fizz_buzzes = [fb.name for fb in fizz_buzz_words if is_divisible(n, fb.number)]

    return ''.join(fizz_buzzes) if fizz_buzzes else str(n)


for a in range(124, 134):
   print to_fizz_buzz_string(a)

print ', '.join(to_fizz_buzz_string(n) for n in range(923, 935))

number_list = []
for number in range(1, end_number+1):
     number_list.append(self.parse_number(number))
return number_list

# -*- coding: utf-8 -*-
"""A generic configurable FizzBuzz."""

from functools import partial


def byn(number, div, out):
    assert isinstance(number, int)
    assert isinstance(div, int)
    if number % div == 0:
        return out
    return ''


def to_str(number):
    return str(number)


class FizzBuzz(object):

    _actions = (
        partial(byn, div=3, out='fizz'),
        partial(byn, div=5, out='buzz'),
    )

    _default_action = partial(to_str)

    def __init__(self, actions=None, default_action=None):
        if actions:
            self._actions = actions
        if default_action:
            self._default_action = default_action

    def response(self, number):
        rstr = ''
        for action in self._actions:
            rstr += action(number)
        if not rstr:
            rstr = self._default_action(number)
        return rstr